diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index eaaeada9..111892e0 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,14 @@
 name: build
 
-on: [push]
+on:
+  push:
+    branches:
+      - master
+      - development
+  pull_request:
+    branches:
+      - master
+      - development
 
 jobs:
   build:
@@ -8,9 +16,9 @@ jobs:
     runs-on: ubuntu-latest
 
     strategy:
-      fail-fast: false
+      fail-fast: true
       matrix:
-        version: ['3.8', '3.10']
+        version: ['3.9']
 
     steps:
     - name: Cancel Previous Runs
@@ -18,32 +26,23 @@ jobs:
       with:
           access_token: ${{ github.token }}
     - uses: actions/checkout@v4
-    - name: Setup conda
-      uses: s-weigand/setup-conda@v1
-      with:
-        update-conda: true
-        python-version: ${{ matrix.version }}
-        conda-channels: anaconda
     - name: Install essential
       run: |
         sudo apt update
-        sudo apt install build-essential
-    - name: Install conda packages
+        sudo apt install build-essential pandoc
+    - name: Install specific 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
-
+        python -m pip install torch==2.4.1 --index-url https://download.pytorch.org/whl/cpu
+        python -m pip install dgl -f https://data.dgl.ai/wheels/torch-2.4/repo.html
     - name: Install the package
-      run: python -m pip install .[test,hpc]
+      run: python -m pip install .[test,doc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 
-    - name: Test with multithreading
-      env:
-        CONDA_PREFIX: /usr/share/miniconda
-      run: mpirun -np 2 coverage run -m pytest tests_hvd
+    # - name: Test with multithreading
+    #   env:
+    #     CONDA_PREFIX: /usr/share/miniconda
+    #   run: mpirun -np 2 coverage run -m pytest tests_hvd
 
     - name: Test with single thread
       env:
diff --git a/.prospector.yml b/.prospector.yml
index f7902836..4d4c8e3b 100644
--- a/.prospector.yml
+++ b/.prospector.yml
@@ -26,4 +26,5 @@ pep257:
         D212,  # Multi-line docstring summary should start at the first line
         D213,  # Multi-line docstring summary should start at the second line
         D404,  # First word of the docstring should not be This
+        R0913, # too many arguments
     ]
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 8d907b82..a2837533 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -2,6 +2,32 @@
 Change Log
 ##########
 
+
+0.4.0 [Unreleased]
+******************
+
+Change
+---------
+
+* Change sugnature of Jastrow and Baclflow modules (#174)
+* Limit testing to Python 3.8 (#174)
+
+
+0.3.3 [Released]
+******************
+
+Change
+-----------
+
+* Fig bug in the AO norm (#172)
+
+0.3.2 [Released]
+******************
+
+Change
+----------
+* Fix a minor OSX bug regarding torch type cast to int
+
 0.3.1 [Released]
 *****************
 
diff --git a/H2.xyz b/H2.xyz
new file mode 100644
index 00000000..f6a613bb
--- /dev/null
+++ b/H2.xyz
@@ -0,0 +1,4 @@
+2
+Properties=species:S:1:pos:R:3 pbc="F F F"
+H        0.00000000       0.00000000      -0.35000000
+H        0.00000000       0.00000000       0.35000000
diff --git a/README.md b/README.md
index 76f14109..13797f29 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,12 @@
 Pytorch Implementation of Real Space Quantum Monte Carlo Simulations of Molecular Systems
 
 [![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)
+[![Build Status](https://github.com/NLESC-JCER/QMCTorch/workflows/build/badge.svg?branch=master)](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://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)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 ## Installation
 
diff --git a/bin/qmctorch_energy_plotter b/bin/qmctorch_energy_plotter
new file mode 100755
index 00000000..2d431d9e
--- /dev/null
+++ b/bin/qmctorch_energy_plotter
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+import h5py
+import matplotlib.pyplot as plt
+import argparse
+
+
+def get_energy(mol):
+    with h5py.File(mol, 'r') as f5:
+        data = f5['wf_opt']['energy'][()]
+    return data
+
+
+def get_correlation_energy(e, e0, ehf):
+    return 1 - (e-e0)/(ehf-e0)
+
+
+def plot_percent_correlation_energy(args):
+
+    nepoch = args.num_epoch
+    energy = []
+    percent_correlation_energy = []
+    for mol in args.filename:
+        e = get_energy(mol)[:nepoch]
+        print(e[-1])
+        energy.append(e)
+        percent_correlation_energy.append(
+            get_correlation_energy(e, args.exact_energy, args.hf_energy))
+
+    plt_fn = plt.plot
+    if args.semi_logy:
+        plt_fn = plt.semilogy
+
+    for ec in percent_correlation_energy:
+        plt_fn(ec)
+    plt.show()
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('filename', nargs='+',
+                        help='name of the files')
+    parser.add_argument('-l', '--labels', nargs='+',
+                        help='label of the data')
+    parser.add_argument('-ne', '--num_epoch', type=int,
+                        default=-1, help='Number of epcoh to plot')
+    parser.add_argument('-e0', '--exact_energy', type=float,
+                        default=None, help='True exact energy of thre system')
+    parser.add_argument('-ehf', '--hf_energy', type=float,
+                        default=None, help='Hartree Fock energy of thre system')
+    parser.add_argument('-log', '--semi_logy', action='store_true',
+                        help='plot on semilog y axis')
+    args = parser.parse_args()
+
+    plot_percent_correlation_energy(args)
diff --git a/docs/conf.py b/docs/conf.py
index f9cac9b1..96a423a5 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -262,4 +262,5 @@
 
 autoclass_content = 'init'
 autodoc_member_order = 'bysource'
-nbsphinx_allow_errors = True
\ No newline at end of file
+nbsphinx_allow_errors = True
+nbsphinx_execute = 'never'
\ No newline at end of file
diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
new file mode 100644
index 00000000..f6a613bb
--- /dev/null
+++ b/docs/example/ase/H2.xyz
@@ -0,0 +1,4 @@
+2
+Properties=species:S:1:pos:R:3 pbc="F F F"
+H        0.00000000       0.00000000      -0.35000000
+H        0.00000000       0.00000000       0.35000000
diff --git a/docs/example/ase/HLi.xyz b/docs/example/ase/HLi.xyz
new file mode 100644
index 00000000..318b8273
--- /dev/null
+++ b/docs/example/ase/HLi.xyz
@@ -0,0 +1,4 @@
+2
+Properties=species:S:1:pos:R:3 pbc="F F F"
+Li       0.00000000       0.00000000       0.00000000
+H        0.00000000       0.00000000       3.14000000
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
new file mode 100644
index 00000000..b777a5bf
--- /dev/null
+++ b/docs/example/ase/h2.py
@@ -0,0 +1,59 @@
+from qmctorch.ase import QMCTorch     
+from qmctorch.ase.optimizer import TorchOptimizer
+from qmctorch.sampler.symmetry import Cinfv, Dinfh
+from ase import Atoms 
+from ase.optimize import GoodOldQuasiNewton, FIRE
+from ase.io import write
+import torch
+import numpy as np
+from qmctorch.utils.plot_data import plot_walkers_traj, plot_correlation_coefficient
+
+torch.random.manual_seed(0)
+np.random.seed(0)
+
+
+configs = (torch.tensor([[0],[1]]), torch.tensor([[0],[1]]))
+
+d = 0.70
+h2 = Atoms('H2', positions=[(0, 0, -d/2), (0, 0, d/2)])
+
+h2.calc = QMCTorch()
+
+# SCF options
+h2.calc.scf_options.calculator = 'adf'
+h2.calc.scf_options.basis = 'dzp'
+
+# WF options
+# h2.calc.wf_options.configs = 'ground_state'
+h2.calc.wf_options.configs = 'single_double(2,4)'
+# h2.calc.wf_options.configs = configs
+h2.calc.wf_options.mix_mo = False
+h2.calc.wf_options.orthogonalize_mo = False
+# h2.calc.wf_options.gto2sto = True
+h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
+
+# sampler options
+h2.calc.sampler_options.nwalkers = 10000
+h2.calc.sampler_options.nstep  = 500
+h2.calc.sampler_options.step_size = 0.5
+h2.calc.sampler_options.ntherm = -1
+h2.calc.sampler_options.ndecor = 10
+h2.calc.sampler_options.symmetry = Dinfh(axis='z')
+
+# solver options
+h2.calc.solver_options.freeze = []
+h2.calc.solver_options.niter = 50
+h2.calc.solver_options.tqdm = True
+h2.calc.solver_options.grad = 'manual'
+
+# options for the resampling
+h2.calc.solver_options.resampling.mode = 'update'
+h2.calc.solver_options.resampling.resample_every = 1
+h2.calc.solver_options.resampling.ntherm_update = 100
+
+
+# Optimize the wave function
+h2.calc.initialize()
+
+h2.get_potential_energy()
+
diff --git a/docs/example/ase/h2_cc.py b/docs/example/ase/h2_cc.py
new file mode 100644
index 00000000..c0011484
--- /dev/null
+++ b/docs/example/ase/h2_cc.py
@@ -0,0 +1,16 @@
+from pyscf import gto, scf, cc
+import numpy as np
+import matplotlib.pyplot as plt 
+
+mol = gto.M(atom="H 0 0 0; H 0 0 0.74")
+cc_scanner = cc.CCSD(scf.RHF(mol)).nuc_grad_method().as_scanner()
+
+dist = np.linspace(0.25,1.5,15)
+energies = []
+for d in dist:
+    atom = 'H 0 0 0; H 0 0 %f' %d
+    e,g = cc_scanner(gto.M(atom=atom))
+    energies.append(e)    
+
+plt.plot(dist, energies)
+plt.show()
\ No newline at end of file
diff --git a/docs/example/ase/lih.py b/docs/example/ase/lih.py
new file mode 100644
index 00000000..4d6917bb
--- /dev/null
+++ b/docs/example/ase/lih.py
@@ -0,0 +1,59 @@
+from qmctorch.ase import QMCTorch     
+from qmctorch.ase.optimizer import TorchOptimizer
+from qmctorch.sampler.symmetry import Cinfv, Dinfh
+from ase import Atoms 
+from ase.optimize import GoodOldQuasiNewton, FIRE
+from ase.io import write
+import torch
+import numpy as np
+from qmctorch.utils.plot_data import plot_walkers_traj, plot_correlation_coefficient
+
+torch.random.manual_seed(0)
+np.random.seed(0)
+
+
+configs = (torch.tensor([[0],[1]]), torch.tensor([[0],[1]]))
+
+d = 0.70
+h2 = Atoms('LiH', positions=[(0, 0, 0), (0, 0, 3.14)])
+
+h2.calc = QMCTorch()
+
+# SCF options
+h2.calc.scf_options.calculator = 'adf'
+h2.calc.scf_options.basis = 'dzp'
+
+# WF options
+# h2.calc.wf_options.configs = 'ground_state'
+h2.calc.wf_options.configs = 'single_double(2,4)'
+# h2.calc.wf_options.configs = configs
+h2.calc.wf_options.mix_mo = False
+h2.calc.wf_options.orthogonalize_mo = False
+# h2.calc.wf_options.gto2sto = True
+h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
+
+# sampler options
+h2.calc.sampler_options.nwalkers = 10000
+h2.calc.sampler_options.nstep  = 500
+h2.calc.sampler_options.step_size = 0.5
+h2.calc.sampler_options.ntherm = -1
+h2.calc.sampler_options.ndecor = 10
+h2.calc.sampler_options.symmetry = None
+
+# solver options
+h2.calc.solver_options.freeze = []
+h2.calc.solver_options.niter = 50
+h2.calc.solver_options.tqdm = True
+h2.calc.solver_options.grad = 'manual'
+
+# options for the resampling
+h2.calc.solver_options.resampling.mode = 'update'
+h2.calc.solver_options.resampling.resample_every = 1
+h2.calc.solver_options.resampling.ntherm_update = 100
+
+
+# Optimize the wave function
+h2.calc.initialize()
+
+h2.get_potential_energy()
+
diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
new file mode 100644
index 00000000..6d0e17dd
--- /dev/null
+++ b/docs/example/autocorrelation/h2.py
@@ -0,0 +1,53 @@
+import torch
+from torch import optim
+
+from qmctorch.sampler import Metropolis
+from qmctorch.scf import Molecule
+from qmctorch.solver import Solver
+from qmctorch.utils.plot_data import plot_correlation_coefficient, plot_integrated_autocorrelation_time
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+torch.manual_seed(0)
+
+# molecule
+mol = Molecule(
+    atom='H 0 0 -0.69; H 0 0 0.69',
+    unit='bohr',
+    calculator='pyscf',
+    basis='sto-3g')
+
+
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+# wave funtion
+wf = SlaterJastrow(mol, kinetic='auto',
+                   jastrow=jastrow,
+                   configs='single(2,2)')
+
+# sampler
+sampler = Metropolis(
+    nwalkers=10,
+    nstep=1000,
+    ntherm=0,
+    ndecor=1,
+    step_size=0.5,
+    ndim=wf.ndim,
+    nelec=wf.nelec,
+    init=mol.domain('normal'),
+    move={
+        'type': 'all-elec',
+        'proba': 'normal'})
+
+opt = optim.Adam(wf.parameters(), lr=0.01)
+
+solver = Solver(wf=wf, sampler=sampler, optimizer=opt)
+
+pos = solver.sampler(wf.pdf)
+obs = solver.sampling_traj(pos)
+
+rho, tau = plot_correlation_coefficient(obs.local_energy)
+print(f'fit exp(-x/tau), tau={tau}')
+iat = plot_integrated_autocorrelation_time(
+    obs.local_energy, rho=rho, C=5)
+print(f"integrated autocorrelation time: {iat}")
diff --git a/docs/example/backflow/backflow.py b/docs/example/backflow/backflow.py
index 7f083aae..d557ef25 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -3,8 +3,13 @@
 from torch import nn
 
 from qmctorch.scf import Molecule
+
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-from qmctorch.wavefunction import SlaterJastrowBackFlow
+
+
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
 class MyBackflow(BackFlowKernelBase):
@@ -14,7 +19,7 @@ def __init__(self, mol, cuda, size=16):
         self.fc1 = nn.Linear(1, size, bias=False)
         self.fc2 = nn.Linear(size, 1, bias=False)
 
-    def forward(self, x):
+    def _backflow_kernel(self, x):
         original_shape = x.shape
         x = x.reshape(-1, 1)
         x = self.fc2(self.fc1(x))
@@ -25,11 +30,17 @@ def forward(self, x):
 mol = Molecule(atom='Li 0. 0. 0.; H 3.14 0. 0.', unit='angs',
                calculator='pyscf', basis='sto-3g', name='LiH')
 
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+# backflow
+backflow = BackFlowTransformation(mol, MyBackflow, {'size': 64})
+
 # define the wave function
-wf = SlaterJastrowBackFlow(mol, kinetic='jacobi',
-                           backflow_kernel=MyBackflow,
-                           backflow_kernel_kwargs={'size': 64},
-                           configs='single_double(2,2)')
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   jastrow=jastrow,
+                   backflow=backflow,
+                   configs='single_double(2,2)')
 
 pos = torch.rand(10, wf.nelec*3)
 print(wf(pos))
diff --git a/docs/example/gpu/h2.py b/docs/example/gpu/h2.py
index ead8d048..755441ff 100644
--- a/docs/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -1,6 +1,7 @@
 from torch import optim
 
 from qmctorch.scf import Molecule
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction import SlaterJastrow
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
@@ -20,9 +21,14 @@
                basis='dzp',
                unit='bohr')
 
+
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
                    configs='cas(2,2)',
+                   jastrow=jastrow,
                    cuda=True)
 
 # sampler
diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
new file mode 100644
index 00000000..dd526405
--- /dev/null
+++ b/docs/example/graph/h2.py
@@ -0,0 +1,62 @@
+import torch
+from torch import optim
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
+from qmctorch.utils import set_torch_double_precision
+from qmctorch.wavefunction.jastrows.graph.mgcn_jastrow import MGCNJastrowFactor
+set_torch_double_precision()
+
+# define the molecule
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='pyscf', basis='dzp', unit='bohr')
+
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+
+# jastrow
+_jastrow = MGCNJastrowFactor(
+            mol,
+            ee_model_kwargs={"n_layers": 2, "feats": 4, "predictor_hidden_feats": 2, "cutoff": 5.0, "gap": 1.0},
+            en_model_kwargs={"n_layers": 2, "feats": 4, "predictor_hidden_feats": 2, "cutoff": 5.0, "gap": 1.0},
+        )
+
+
+# define the wave function
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='ground_state', 
+                   jastrow=jastrow) #.gto2sto()
+
+# sampler
+sampler = Metropolis(nwalkers=100, nstep=10, step_size=0.25,
+                     nelec=wf.nelec, ndim=wf.ndim, init=mol.domain('atomic'))
+
+# optimizer
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-3},
+           {'params': wf.ao.parameters(), 'lr': 1E-6},
+           {'params': wf.mo.parameters(), 'lr': 2E-3},
+           {'params': wf.fc.parameters(), 'lr': 2E-3}]
+opt = optim.Adam(lr_dict, lr=1E-3)
+
+
+# solver
+solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)
+solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
+                 loss='energy', grad='manual',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'ntherm_update': 5}
+                 )
+
+pos = torch.rand(10, 6)
+pos.requires_grad = True
+
+solver.wf.local_energy(pos)
+
+# single point
+# obs = solver.single_point()
+obs = solver.run(5)
diff --git a/docs/example/graph/jast_graph.py b/docs/example/graph/jast_graph.py
new file mode 100644
index 00000000..d294fd0a
--- /dev/null
+++ b/docs/example/graph/jast_graph.py
@@ -0,0 +1,35 @@
+
+from qmctorch.wavefunction.jastrows.graph.mgcn_jastrow import MGCNJastrowFactor
+import torch
+from torch.autograd import grad
+from types import SimpleNamespace
+# from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+from dgllife.model.model_zoo.mgcn_predictor import MGCNPredictor
+
+nup = 2
+ndown = 2
+atomic_pos = torch.rand(2, 3)
+atom_types = ["Li", "H"]
+
+mol = SimpleNamespace(
+    nup=nup,
+    ndown=ndown,
+    atom_coords=atomic_pos,
+    atoms=atom_types,
+)
+
+jast = MGCNJastrowFactor(
+            mol,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
+
+
+pos = torch.rand(10, 12)
+# pos.requires_grad = True
+# jval = jast(pos)
+
+# gval = jast(pos, derivative=1)
+# hval = jast(pos, derivative=2)
+
+jast, djast, d2jast = jast(pos, derivative=[0, 1, 2], sum_grad=False)
diff --git a/docs/example/horovod/h2.py b/docs/example/horovod/h2.py
index 69eba976..4e4b76f3 100644
--- a/docs/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -22,9 +22,9 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', unit='bohr',
                calculator='pyscf', basis='sto-3g',
-               unit='bohr', rank=hvd.local_rank())
+               rank=hvd.local_rank(), mpi_size=hvd.local_size())
 
 
 # define the wave function
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 7ff7e7da..a9e49c2f 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -1,14 +1,15 @@
-
+import torch
+import numpy as np
 from torch import optim
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+
 from qmctorch.solver import Solver
-from qmctorch.sampler import Metropolis
+from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
-
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+from qmctorch.utils.plot_data import (plot_energy, plot_data)
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -16,6 +17,8 @@
 # bond dissociation energy 4.478 eV -> 0.16 hartree
 
 set_torch_double_precision()
+torch.random.manual_seed(0)
+np.random.seed(0)
 
 # define the molecule
 mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
@@ -23,17 +26,23 @@
                basis='sto-3g',
                unit='bohr')
 
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
                    configs='single_double(2,2)',
-                   jastrow_kernel=PadeJastrowKernel).gto2sto()
+                   jastrow=jastrow)
 
 # sampler
-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'})
+# 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=10, nstep=200, nelec=wf.nelec, 
+                     ntherm=100, ndecor=10,
+                     step_size=0.05, init=mol.domain('atomic'))
 
 # optimizer
 lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
@@ -46,23 +55,44 @@
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
 
 # QMC solver
-solver = Solver(wf=wf, sampler=sampler,
-                             optimizer=opt, scheduler=None)
+solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)
 
 # perform a single point calculation
-obs = solver.single_point()
+# obs = solver.single_point()
 
 # configure the solver
 solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
                  loss='energy', grad='manual',
-                 ortho_mo=False, clip_loss=False,
+                 ortho_mo=False, clip_loss=False, clip_threshold=2,
                  resampling={'mode': 'update',
                              'resample_every': 1,
-                             'nstep_update': 25})
+                             'nstep_update': 150,
+                             'ntherm_update': 50}
+                 )
+
+pos = torch.rand(10, 6)
+pos.requires_grad = True
+
+wf.fc.weight.data = torch.rand(1, 4) - 0.5
+print(wf(pos))
+
+solver.evaluate_grad_manual(pos)
+print(wf.jastrow.jastrow_kernel.weight.grad)
+wf.zero_grad()
+
+
+solver.evaluate_grad_manual_3(pos)
+print(wf.jastrow.jastrow_kernel.weight.grad)
+wf.zero_grad()
+
+solver.evaluate_grad_auto(pos)
+print(wf.jastrow.jastrow_kernel.weight.grad)
+wf.zero_grad()
+
 
 # optimize the wave function
-obs = solver.run(50)
+# obs = solver.run(5)  # , batchsize=10)
 
 # plot
-plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname='jastrow.jastrow_kernel.weight')
+# plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
+# plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index ef612527..bba8df9f 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -2,9 +2,9 @@
 
 # Select the SCF calculator
 calc = ['pyscf',            # pyscf  
-        'adf',          # adf 2019 
-        'adf2019'               # adf 2020+
-    ][0]
+        'adf',              # adf 2020+ 
+        'adf2019'           # adf 2019
+    ][1]
 
 # select an appropriate basis
 basis = {
@@ -17,7 +17,8 @@
 mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
             calculator=calc,
             basis=basis,
-            unit='bohr')
+            unit='bohr',
+            redo_scf=True)
 
 
 
diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
new file mode 100644
index 00000000..3a1c603c
--- /dev/null
+++ b/docs/example/single_point/h2.py
@@ -0,0 +1,49 @@
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
+
+# define the molecule
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='pyscf', basis='dzp', unit='bohr')
+
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+# define the wave function
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='ground_state', jastrow=jastrow) #.gto2sto()
+
+# sampler
+sampler = Metropolis(nwalkers=1000, nstep=1000, step_size=0.25,
+                     nelec=wf.nelec, ndim=wf.ndim,
+                     init=mol.domain('atomic'),
+                     move={'type': 'one-elec', 'proba': 'normal'},
+                     logspace=False)
+
+
+# pos = sampler(wf.pdf)
+# e, s, err = wf._energy_variance_error(pos)
+
+# # print data
+# print('  Energy   : %f +/- %f' %
+#       (e.detach().item(), err.detach().item()))
+# print('  Variance : %f' % s.detach().item())
+
+# solver
+solver = Solver(wf=wf, sampler=sampler)
+
+# single point
+obs = solver.single_point()
+
+# # reconfigure sampler
+# solver.sampler.ntherm = 0
+# solver.sampler.ndecor = 5
+
+# # compute the sampling traj
+# pos = solver.sampler(solver.wf.pdf)
+# obs = solver.sampling_traj(pos)
+# plot_walkers_traj(obs.local_energy, walkers='mean')
diff --git a/docs/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
index 8ab31da3..507a78cb 100644
--- a/docs/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -1,17 +1,22 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.sampler import Metropolis
 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', redo_scf=True)
 
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
-                   configs='ground_state')
+                   configs='ground_state', jastrow=jastrow)
 
 # sampler
 sampler = Metropolis(nwalkers=1000, nstep=500, step_size=0.25,
diff --git a/docs/index.rst b/docs/index.rst
index 496b8ea3..48590f56 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -32,6 +32,7 @@ Quantum Monte Carlo with Pytorch
    notebooks/correlation
    notebooks/create_jastrow
    notebooks/create_backflow
+   notebooks/combining_jastrow
    notebooks/horovod
 
 
diff --git a/docs/notebooks/clean_notebooks.sh b/docs/notebooks/clean_notebooks.sh
new file mode 100644
index 00000000..ef83540f
--- /dev/null
+++ b/docs/notebooks/clean_notebooks.sh
@@ -0,0 +1,13 @@
+#! /bin/bash
+# Remove all the output from the jupyter notebooks
+
+
+for x in $(ls molecule.ipynb);
+do
+    echo ${x}
+    jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace "${x}"
+    jupyter nbconvert --to notebook --execute --inplace "${x}"
+done
+
+# Clean up temporal files
+# git clean -fdx
\ No newline at end of file
diff --git a/docs/notebooks/combining_jastrow.ipynb b/docs/notebooks/combining_jastrow.ipynb
new file mode 100644
index 00000000..2861fd47
--- /dev/null
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -0,0 +1,199 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Combining several Jastrow Factors\n",
+    "\n",
+    "It is often useful to use mutliple jastrow factors to go beyond the simple electron-electron Jastrow. We show here how to do that easily through our "
+   ]
+  },
+  {
+   "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 torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec import (\n",
+    "    JastrowFactor as JastrowFactorElecElec,\n",
+    "    FullyConnectedJastrowKernel as FCEE,\n",
+    ")\n",
+    "from qmctorch.wavefunction.jastrows.elec_nuclei import (\n",
+    "    JastrowFactor as JastrowFactorElecNuclei,\n",
+    "    FullyConnectedJastrowKernel as FCEN,\n",
+    ")"
+   ]
+  },
+  {
+   "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."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We first need a 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|  Removing HLi_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -7.85928101642664\n",
+      "INFO:QMCTorch|  Molecule name       : HLi\n",
+      "INFO:QMCTorch|  Number of electrons : 4\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 6\n",
+      "INFO:QMCTorch|  Number of MOs       : 6\n",
+      "INFO:QMCTorch|  SCF Energy          : -7.859 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "mol = Molecule(\n",
+    "        atom=\"Li 0 0 0; H 0 0 3.14\", \n",
+    "        unit='bohr', \n",
+    "        calculator=\"pyscf\",\n",
+    "        basis=\"sto-3g\",\n",
+    "        redo_scf=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We are going to use here to predefined Jastrow factors, one for electron-electron interactions and one for electon-nuclei interactions. Both use a fully connected neural network "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# elec-elec jastrow factor\n",
+    "jastrow_ee = JastrowFactorElecElec(mol, FCEE)\n",
+    "\n",
+    "# elec-nuclei jastrow factor\n",
+    "jastrow_en = JastrowFactorElecNuclei(mol, FCEN)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then pass a list containing these two jastrow factors to the wave function to combine them"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "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      : FullyConnectedJastrowKernel + FullyConnectedJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 6\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   : 367\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, jastrow=[jastrow_ee, jastrow_en])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[-0.1107],\n",
+      "        [-0.1423],\n",
+      "        [-0.1496],\n",
+      "        [ 0.0150],\n",
+      "        [ 0.0299],\n",
+      "        [ 0.1291],\n",
+      "        [-0.1664],\n",
+      "        [ 0.1220],\n",
+      "        [ 0.2130],\n",
+      "        [-0.0605]], grad_fn=<MulBackward0>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "pos = torch.rand(10, wf.nelec*3)\n",
+    "print(wf(pos))"
+   ]
+  }
+ ],
+ "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": 4
+}
diff --git a/docs/notebooks/correlation.ipynb b/docs/notebooks/correlation.ipynb
index ef68e3c8..876ee1eb 100644
--- a/docs/notebooks/correlation.ipynb
+++ b/docs/notebooks/correlation.ipynb
@@ -13,17 +13,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "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\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"
+    "from qmctorch.utils.plot_data import blocking, plot_blocking_energy\n",
+    "from qmctorch.utils.plot_data  import plot_correlation_coefficient, plot_integrated_autocorrelation_time"
    ]
   },
   {
@@ -38,7 +49,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -47,28 +58,28 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_dzp.hdf5 and redo SCF calculations\n",
       "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
+      "converged SCF energy = -1.07280585930373\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|  Basis set           : dzp\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|  Number of AOs       : 10\n",
+      "INFO:QMCTorch|  Number of MOs       : 10\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.073 Hartree\n"
      ]
     }
    ],
    "source": [
     "set_torch_double_precision()\n",
-    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -78,12 +89,12 @@
       "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|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 10\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|  Number var  param   : 122\n",
       "INFO:QMCTorch|  Cuda support        : False\n"
      ]
     }
@@ -102,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -142,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -172,23 +183,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:46<00:00, 10.68it/s]\n"
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 231.36it/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|   Acceptance rate     : 61.47 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 231.25 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 2.16 sec.\n",
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch|  Sampling trajectory\n"
      ]
@@ -197,7 +208,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Energy  : 100%|██████████| 500/500 [01:43<00:00,  4.85it/s]\n"
+      "INFO:QMCTorch|  Energy  : 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 177.86it/s]\n"
      ]
     }
    ],
@@ -216,12 +227,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -250,18 +261,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "28"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -282,12 +303,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -311,7 +332,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -326,9 +347,8 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index cd993268..43f8b237 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -13,33 +13,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n",
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_adf_dzp.hdf5 and redo SCF calculations\n",
       "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
+      "[05.12|11:49:03] PLAMS working folder: /home/nico/QMCTorch/docs/notebooks/plams_workdir\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 calculator      : adf\n",
+      "INFO:QMCTorch|  Basis set           : dzp\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|  Number of AOs       : 10\n",
+      "INFO:QMCTorch|  Number of MOs       : 10\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.082 Hartree\n"
      ]
     }
    ],
    "source": [
     "import torch\n",
     "from qmctorch.scf import Molecule\n",
-    "from qmctorch.wavefunction import SlaterJastrowBackFlow\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase\n",
+    "from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation\n",
+    "\n",
     "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
    ]
   },
@@ -54,17 +61,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "from torch import nn \n",
-    "class MyBackflow(BackFlowKernelBase):\n",
+    "class MyBackflowKernel(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",
+    "    def _backflow_kernel(self, x):\n",
     "        original_shape = x.shape\n",
     "        x = x.reshape(-1,1)\n",
     "        x = self.fc2(self.fc1(x))\n",
@@ -76,13 +83,29 @@
    "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 :"
+    "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 `SlaterJastrow` wave function ansatz we first need to instantiate a backflow layer using this kernel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "backflow = BackFlowTransformation(mol, MyBackflowKernel, backflow_kernel_kwargs={'size': 8})"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then use this backflow transformation in the call of the wave function:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -92,41 +115,39 @@
       "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|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 10\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|  Number var  param   : 134\n",
       "INFO:QMCTorch|  Cuda support        : False\n"
      ]
     }
    ],
    "source": [
-    "wf = SlaterJastrowBackFlow(mol, \n",
-    "                   backflow_kernel=MyBackflow,\n",
-    "                   backflow_kernel_kwargs={'size' : 64})"
+    "wf = SlaterJastrow(mol, backflow=backflow)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "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"
+      "tensor([[0.0871],\n",
+      "        [0.0390],\n",
+      "        [0.0783],\n",
+      "        [0.1098],\n",
+      "        [0.0740],\n",
+      "        [0.0394],\n",
+      "        [0.1762],\n",
+      "        [0.0719],\n",
+      "        [0.0748],\n",
+      "        [0.0882]], grad_fn=<MulBackward0>)\n"
      ]
     }
    ],
@@ -134,18 +155,11 @@
     "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",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -160,9 +174,8 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index 20216768..de55cc49 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -13,7 +13,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "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 torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import JastrowKernelElectronElectronBase"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -22,25 +46,22 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_dzp.hdf5 and redo SCF calculations\n",
       "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
+      "converged SCF energy = -1.07280585930373\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|  Basis set           : dzp\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|  Number of AOs       : 10\n",
+      "INFO:QMCTorch|  Number of MOs       : 10\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.073 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)"
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -54,12 +75,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "from torch import nn \n",
-    "class MyJastrow(JastrowKernelElectronElectronBase):\n",
+    "class MyJastrowKernel(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",
@@ -84,15 +105,28 @@
     "\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",
+    "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\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 :"
+    "To use this new Jastrow kernel in the `SlaterJastrow` wave function ansatz we first need to instantiate a Jastrow factor that uses the kernel. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel, kernel_kwargs={'size': 64})"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This jastrow factor can then be passed as an argument of the `SlaterJastrow` wavefunction."
    ]
   },
   {
@@ -104,33 +138,48 @@
      "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|  Jastrow kernel      : ee -> MyJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 10\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|  Number var  param   : 249\n",
       "INFO:QMCTorch|  Cuda support        : False\n"
      ]
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, jastrow_kernel=MyJastrow, jastrow_kernel_kwargs={'size' : 64})"
+    "wf = SlaterJastrow(mol, jastrow=jastrow)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[0.3465],\n",
+      "        [0.2254],\n",
+      "        [0.1533],\n",
+      "        [0.2485],\n",
+      "        [0.4022],\n",
+      "        [0.2991],\n",
+      "        [0.2480],\n",
+      "        [0.3140],\n",
+      "        [0.3298],\n",
+      "        [0.1233]], grad_fn=<MulBackward0>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "pos = torch.rand(10, wf.nelec*3)\n",
+    "print(wf(pos))"
    ]
   },
   {
@@ -143,7 +192,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -158,9 +207,8 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/geoopt.ipynb b/docs/notebooks/geoopt.ipynb
index 314f0c1c..f47d6c37 100644
--- a/docs/notebooks/geoopt.ipynb
+++ b/docs/notebooks/geoopt.ipynb
@@ -33,7 +33,7 @@
     "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.plot_data import plot_energy\n",
     "from qmctorch.utils import set_torch_double_precision\n",
     "set_torch_double_precision()"
    ]
@@ -56,7 +56,6 @@
      "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",
@@ -94,7 +93,7 @@
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| Wave Function\n",
       "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
       "INFO:QMCTorch|  Highest MO included : 2\n",
       "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
       "INFO:QMCTorch|  Number of confs     : 4\n",
@@ -105,7 +104,7 @@
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| Wave Function\n",
       "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
       "INFO:QMCTorch|  Highest MO included : 2\n",
       "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
       "INFO:QMCTorch|  Number of confs     : 4\n",
@@ -151,11 +150,6 @@
      "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",
@@ -204,266 +198,255 @@
       "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|  epoch 0 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.051299 +/- 0.011930\n",
+      "INFO:QMCTorch|  variance : 0.377259\n",
+      "INFO:QMCTorch|  epoch done in 0.08 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|  epoch 1 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.039677 +/- 0.011319\n",
+      "INFO:QMCTorch|  variance : 0.357927\n",
+      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 2 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.083498 +/- 0.011489\n",
+      "INFO:QMCTorch|  variance : 0.363315\n",
+      "INFO:QMCTorch|  epoch done in 0.13 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 3 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.096306 +/- 0.012919\n",
+      "INFO:QMCTorch|  variance : 0.408541\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|  epoch 4 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.073275 +/- 0.011114\n",
+      "INFO:QMCTorch|  variance : 0.351444\n",
+      "INFO:QMCTorch|  epoch done in 0.14 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|  epoch 5 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.091809 +/- 0.011652\n",
+      "INFO:QMCTorch|  variance : 0.368468\n",
+      "INFO:QMCTorch|  epoch done in 0.11 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|  epoch 6 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.086389 +/- 0.011696\n",
+      "INFO:QMCTorch|  variance : 0.369854\n",
+      "INFO:QMCTorch|  epoch done in 0.51 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|  epoch 7 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.106363 +/- 0.015236\n",
+      "INFO:QMCTorch|  variance : 0.481804\n",
+      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 8 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.103029 +/- 0.011551\n",
+      "INFO:QMCTorch|  variance : 0.365266\n",
+      "INFO:QMCTorch|  epoch done in 0.09 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 9 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.104694 +/- 0.010543\n",
+      "INFO:QMCTorch|  variance : 0.333408\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|  epoch 10 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.101184 +/- 0.010772\n",
+      "INFO:QMCTorch|  variance : 0.340643\n",
+      "INFO:QMCTorch|  epoch done in 0.83 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 11 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.118775 +/- 0.010548\n",
+      "INFO:QMCTorch|  variance : 0.333553\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|  epoch 12 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.111163 +/- 0.010536\n",
+      "INFO:QMCTorch|  variance : 0.333193\n",
+      "INFO:QMCTorch|  epoch done in 0.10 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 13 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.093243 +/- 0.010991\n",
+      "INFO:QMCTorch|  variance : 0.347571\n",
+      "INFO:QMCTorch|  epoch done in 0.15 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 14 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.098148 +/- 0.009786\n",
+      "INFO:QMCTorch|  variance : 0.309451\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 15 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.110943 +/- 0.009883\n",
+      "INFO:QMCTorch|  variance : 0.312525\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 16 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.130522 +/- 0.010770\n",
+      "INFO:QMCTorch|  variance : 0.340589\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|  epoch 17 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.119832 +/- 0.010397\n",
+      "INFO:QMCTorch|  variance : 0.328774\n",
+      "INFO:QMCTorch|  epoch done in 0.84 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 18 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.114476 +/- 0.010044\n",
+      "INFO:QMCTorch|  variance : 0.317618\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|  epoch 19 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.127139 +/- 0.009782\n",
+      "INFO:QMCTorch|  variance : 0.309344\n",
+      "INFO:QMCTorch|  epoch done in 0.09 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|  epoch 20 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.141108 +/- 0.010158\n",
+      "INFO:QMCTorch|  variance : 0.321225\n",
+      "INFO:QMCTorch|  epoch done in 0.16 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|  epoch 21 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.120979 +/- 0.009740\n",
+      "INFO:QMCTorch|  variance : 0.307994\n",
+      "INFO:QMCTorch|  epoch done in 0.09 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|  epoch 22 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.130151 +/- 0.010171\n",
+      "INFO:QMCTorch|  variance : 0.321641\n",
+      "INFO:QMCTorch|  epoch done in 0.16 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|  epoch 23 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.126904 +/- 0.009565\n",
+      "INFO:QMCTorch|  variance : 0.302478\n",
+      "INFO:QMCTorch|  epoch done in 0.10 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 24 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.140780 +/- 0.009760\n",
+      "INFO:QMCTorch|  variance : 0.308645\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|  epoch 25 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.122666 +/- 0.009864\n",
+      "INFO:QMCTorch|  variance : 0.311916\n",
+      "INFO:QMCTorch|  epoch done in 0.14 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 26 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.124710 +/- 0.009316\n",
+      "INFO:QMCTorch|  variance : 0.294589\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|  epoch 27 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.130382 +/- 0.009266\n",
+      "INFO:QMCTorch|  variance : 0.293020\n",
+      "INFO:QMCTorch|  epoch done in 0.18 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 28 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.124134 +/- 0.009203\n",
+      "INFO:QMCTorch|  variance : 0.291026\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|  epoch 29 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.148873 +/- 0.008958\n",
+      "INFO:QMCTorch|  variance : 0.283281\n",
+      "INFO:QMCTorch|  epoch done in 0.11 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 30 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.151410 +/- 0.009124\n",
+      "INFO:QMCTorch|  variance : 0.288521\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|  epoch 31 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.132741 +/- 0.008910\n",
+      "INFO:QMCTorch|  variance : 0.281774\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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 32 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157418 +/- 0.009251\n",
+      "INFO:QMCTorch|  variance : 0.292552\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|  epoch 33 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.139773 +/- 0.009447\n",
+      "INFO:QMCTorch|  variance : 0.298734\n",
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 34 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.141193 +/- 0.009174\n",
+      "INFO:QMCTorch|  variance : 0.290105\n",
+      "INFO:QMCTorch|  epoch done in 0.10 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 35 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.142530 +/- 0.011028\n",
+      "INFO:QMCTorch|  variance : 0.348741\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|  epoch 36 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.135991 +/- 0.009584\n",
+      "INFO:QMCTorch|  variance : 0.303085\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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 37 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.149069 +/- 0.009036\n",
+      "INFO:QMCTorch|  variance : 0.285733\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|  epoch 38 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.146994 +/- 0.009392\n",
+      "INFO:QMCTorch|  variance : 0.297009\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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 39 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.141153 +/- 0.008568\n",
+      "INFO:QMCTorch|  variance : 0.270943\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|  epoch 40 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.146822 +/- 0.008714\n",
+      "INFO:QMCTorch|  variance : 0.275570\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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 41 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.137690 +/- 0.008836\n",
+      "INFO:QMCTorch|  variance : 0.279429\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|  epoch 42 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.140852 +/- 0.008685\n",
+      "INFO:QMCTorch|  variance : 0.274655\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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|  epoch 43 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.141535 +/- 0.008415\n",
+      "INFO:QMCTorch|  variance : 0.266091\n",
+      "INFO:QMCTorch|  epoch done in 0.09 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|  epoch 44 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156989 +/- 0.008510\n",
+      "INFO:QMCTorch|  variance : 0.269122\n",
+      "INFO:QMCTorch|  epoch done in 0.12 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 45 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.136263 +/- 0.008505\n",
+      "INFO:QMCTorch|  variance : 0.268963\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 46 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.135993 +/- 0.009332\n",
+      "INFO:QMCTorch|  variance : 0.295104\n",
+      "INFO:QMCTorch|  epoch done in 0.15 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 47 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.151198 +/- 0.008536\n",
+      "INFO:QMCTorch|  variance : 0.269921\n",
       "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"
+      "INFO:QMCTorch|  epoch 48 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.142816 +/- 0.008155\n",
+      "INFO:QMCTorch|  variance : 0.257869\n",
+      "INFO:QMCTorch|  epoch done in 0.13 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 49 | 1000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.140517 +/- 0.008837\n",
+      "INFO:QMCTorch|  variance : 0.279447\n",
+      "INFO:QMCTorch|  epoch done in 0.12 sec.\n"
      ]
     }
    ],
@@ -483,12 +466,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -522,5 +505,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
index 9f78957d..3f49e7fc 100644
--- a/docs/notebooks/gpu.ipynb
+++ b/docs/notebooks/gpu.ipynb
@@ -19,29 +19,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import torch\n",
     "from torch import optim\n",
@@ -63,17 +43,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CUDA not available, install torch with cuda support to proceed\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if torch.cuda.is_available():\n",
     "    wf = SlaterJastrow(mol, cuda=True)\n",
@@ -104,8 +76,7 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
index d7be2325..99710989 100644
--- a/docs/notebooks/molecule.ipynb
+++ b/docs/notebooks/molecule.ipynb
@@ -12,7 +12,14 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:09.247655Z",
+     "iopub.status.busy": "2023-12-05T08:36:09.247417Z",
+     "iopub.status.idle": "2023-12-05T08:36:13.594982Z",
+     "shell.execute_reply": "2023-12-05T08:36:13.593903Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -52,7 +59,14 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:13.598953Z",
+     "iopub.status.busy": "2023-12-05T08:36:13.598568Z",
+     "iopub.status.idle": "2023-12-05T08:36:14.242173Z",
+     "shell.execute_reply": "2023-12-05T08:36:14.241415Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -60,31 +74,12 @@
      "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|  Reusing scf results from H2_pyscf_dzp.hdf5\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')"
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr')"
    ]
   },
   {
@@ -97,8 +92,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:14.244567Z",
+     "iopub.status.busy": "2023-12-05T08:36:14.244372Z",
+     "iopub.status.idle": "2023-12-05T08:36:14.980847Z",
+     "shell.execute_reply": "2023-12-05T08:36:14.980134Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -106,22 +108,22 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_dzp.hdf5 and redo SCF calculations\n",
       "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
+      "converged SCF energy = -1.07280585930373\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|  Basis set           : dzp\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|  Number of AOs       : 10\n",
+      "INFO:QMCTorch|  Number of MOs       : 10\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.073 Hartree\n"
      ]
     }
    ],
    "source": [
-    "mol = Molecule(atom='h2.xyz', unit='bohr', redo_scf=True)"
+    "mol = Molecule(atom='h2.xyz', unit='bohr', calculator='pyscf', redo_scf=True)"
    ]
   },
   {
@@ -144,8 +146,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:14.983439Z",
+     "iopub.status.busy": "2023-12-05T08:36:14.983263Z",
+     "iopub.status.idle": "2023-12-05T08:36:15.749731Z",
+     "shell.execute_reply": "2023-12-05T08:36:15.748867Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -153,6 +162,7 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-6g.hdf5 and redo SCF calculations\n",
       "INFO:QMCTorch|  Running scf  calculation\n",
       "converged SCF energy = -1.07589040772972\n",
       "INFO:QMCTorch|  Molecule name       : H2\n",
@@ -186,16 +196,23 @@
     "### 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",
+    "* ADF 2019  : `calculator = 'adf2019'`\n",
     "\n",
-    "So for example if ADF2019 is installed the following command will use ADF to compute the electronic structure of the molecule."
+    "So for example if ADF is installed the following command will use ADF to compute the electronic structure of the molecule."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:15.752772Z",
+     "iopub.status.busy": "2023-12-05T08:36:15.752506Z",
+     "iopub.status.idle": "2023-12-05T08:36:21.285175Z",
+     "shell.execute_reply": "2023-12-05T08:36:21.284137Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -204,14 +221,21 @@
       "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"
+      "[05.12|09:44:38] PLAMS working folder: /home/nico/QMCTorch/docs/notebooks/plams_workdir\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : adf\n",
+      "INFO:QMCTorch|  Basis set           : dzp\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 10\n",
+      "INFO:QMCTorch|  Number of MOs       : 10\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.082 Hartree\n"
      ]
     }
    ],
    "source": [
     "try:\n",
-    "    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='adf2019', basis='dzp')\n",
+    "    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='adf', basis='dzp')\n",
     "except Exception as expt:\n",
     "    print(expt)"
    ]
@@ -243,8 +267,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-12-05T08:36:21.288625Z",
+     "iopub.status.busy": "2023-12-05T08:36:21.288333Z",
+     "iopub.status.idle": "2023-12-05T08:36:21.308278Z",
+     "shell.execute_reply": "2023-12-05T08:36:21.307294Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -252,7 +283,7 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Loading data from LiH_adf_dz.hdf5\n"
+      "INFO:QMCTorch|  Loading data from ./hdf5/LiH_adf_dz.hdf5\n"
      ]
     }
    ],
@@ -263,7 +294,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -278,9 +309,8 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/sampling.ipynb b/docs/notebooks/sampling.ipynb
index 448018dc..d1b83cfb 100644
--- a/docs/notebooks/sampling.ipynb
+++ b/docs/notebooks/sampling.ipynb
@@ -33,7 +33,7 @@
     "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"
+    "from qmctorch.utils.plot_data import plot_walkers_traj"
    ]
   },
   {
@@ -63,7 +63,16 @@
      "text": [
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Reusing scf results from water_pyscf_sto-3g.hdf5\n"
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -74.9630875425187\n",
+      "INFO:QMCTorch|  Molecule name       : water\n",
+      "INFO:QMCTorch|  Number of electrons : 10\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 7\n",
+      "INFO:QMCTorch|  Number of MOs       : 7\n",
+      "INFO:QMCTorch|  SCF Energy          : -74.963 Hartree\n"
      ]
     }
    ],
@@ -97,7 +106,7 @@
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| Wave Function\n",
       "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
       "INFO:QMCTorch|  Highest MO included : 7\n",
       "INFO:QMCTorch|  Configurations      : ground_state\n",
       "INFO:QMCTorch|  Number of confs     : 1\n",
@@ -165,11 +174,6 @@
      "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",
@@ -199,16 +203,16 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:46<00:00,  4.70it/s]"
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 187.74it/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"
+      "INFO:QMCTorch|   Acceptance rate     : 2.66 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 187.66 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 2.66 sec.\n"
      ]
     },
     {
@@ -221,7 +225,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fef4e5ea700>"
+       "<matplotlib.collections.PathCollection at 0x7fa882af5610>"
       ]
      },
      "execution_count": 6,
@@ -230,7 +234,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDm0lEQVR4nO3df3Bc1X3//9fKINkC/cKywY4ECCxMGyJ+mOBQVNdJXJNMCCGfJE3mw7f8iIZpJg5jfrXgzqcwfOfTcdKYMfnSkDCNCE5Lvk4LTRxoS4yTYkUpIcQ/UOD7sZCpsCXLGMtoJWHZK1va7x/23Vxd3d29d/f+3H0+ZjS2tLv3nnvv7p73Ped9zkmk0+m0AAAAQlARdgEAAED5IhABAAChIRABAAChIRABAAChIRABAAChIRABAAChIRABAAChIRABAAChOSPsAuQyPT2toaEh1dTUKJFIhF0cAADgQDqd1vj4uBYvXqyKitxtHpEORIaGhtTc3Bx2MQAAQAEGBgbU1NSU8zmRDkRqamoknTqQ2trakEsDAACcGBsbU3Nzc6YezyXSgYjRHVNbW0sgAgBAzDhJqyBZFQAAhIZABAAAhIZABAAAhIZABAAAhIZABAAAhIZABAAAhCawQOTrX/+6EomE7rrrrqB2CQAAIi6QQOTVV1/VE088oba2tiB2BwAAYsL3QOT999/XzTffrH/4h39QQ0OD37sDAAAx4nsgsmbNGn3qU5/SqlWr8j43lUppbGxsxg8AAChdvk7xvnnzZu3cuVOvvvqqo+evX79eDz/8sJ9FAgAAEeJbi8jAwIDWrl2rp59+WnPnznX0mnXr1ml0dDTzMzAw4FfxAABABCTS6XTajw3/5Cc/0Wc/+1nNmTMn87epqSklEglVVFQolUrNeMzO2NiY6urqNDo6yqJ3CEXPYFKd3f3qaG9RW1N92MUBgFhwU3/71jXz8Y9/XL/73e9m/O3222/XpZdeqvvvvz9vEAJEQWd3v57vOShJ+taXrgy5NABQenwLRGpqanTZZZfN+NtZZ52l+fPnz/o7EFUd7S0z/gUAeMvXZFUg7tqa6mkJAQAfBRqIvPTSS0HuDgAARBxrzQAAgNAQiAAAgNAQiAAAgNAQiAAAgNAQiAAAgNAQiACAQz2DSa3dvEs9g8mwixJpnCe4QSACAA4ZM+12dveHXZRIsQYenCe4wYRmAOAQM+3asy6FwHmCG74teucFFr0DgOhjcUhYRWLROwBAeWApBBSDHBEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAABAaAhEAKBE9g0mt3bxLPYPJsIsCOEYgAgAlorO7X8/3HFRnd3/YRQEcOyPsAgAAvNHR3jLjXyAOCEQAoES0NdXrW1+6MuxiAK7QNQMAAEJDIAIAAEJDIAIAAEJDIAIAAEJDIAIAAEJDIAIAAEJDIAKUMWbijD+uIeKOQAQoY8zEGX9cQ8Sdr4HId77zHbW1tam2tla1tbW69tpr9R//8R9+7hKACx3tLbqhbREzccYY1xBxl0in02m/Nv7cc89pzpw5am1tVTqd1qZNm/TNb35Tu3bt0gc/+MG8rx8bG1NdXZ1GR0dVW1vrVzEBAICH3NTfvgYids455xx985vfVEdHR97nEogA8EvPYFKd3f3qaG9RW1N92MUBSoqb+juwtWampqb0L//yLzp69KiuvfZa2+ekUimlUqnM72NjY0EVD0CZMXIrJLE+CxAi35NVf/e73+nss89WVVWVvvKVr+jHP/6x/vAP/9D2uevXr1ddXV3mp7m52e/iAShT5FbEE6OESo/vXTOTk5Pav3+/RkdH9cwzz+h73/uetm/fbhuM2LWINDc30zUDAJAkrd28S8/3HNQNbYtoyYqwSHXNVFZWasmSJZKkZcuW6dVXX9W3vvUtPfHEE7OeW1VVpaqqKr+LBPiK3APAP0YLFi1ZpSOwHBHD9PT0jFYPoNSQewD4p62pns9VifE1EFm3bp0++clP6vzzz9f4+Lh++MMf6qWXXtLPfvYzP3cLhCpKd2y0zgCIOl8DkXfffVe33HKLDh48qLq6OrW1telnP/uZ/vRP/9TP3QKhitIdG60z0UJgCMzmayDS2dnp5+YB5BGl1hkQGBaDIK50BZ4jAiA4UWqdAYFhMaIUxBEUeYtABAACQmBYuCgFcVEKikoBgQgAIPKiFMRFKSgqBQQiAAC4EKWgqBT4PsU7UA6YdhoACkMgAnjA6DPu7O4PuygAECt0zQAeoM8YAApDIAJ4gD5jACgMXTMAACA0BCIAAJSpKCTaE4gAAFCmopBoT44IAMAWU5mXvigk2hOIAABsMZV56YtCoj1dMwA8EYW+Zniro71FN7Qtit2wdN6L8UIgAsATUehrhreMu+W4dcvwXowXumYAeCIKfc2AxHsxbhLpdDoddiGyGRsbU11dnUZHR1VbWxt2cQAAgANu6m+6ZgAAQGgIRAAAQGgIRAAAQGgIRAAAQGgIRADMwjwMAIJCIIKSQMXpLeZhABAUAhGUBCpOb8V1Rs2wEAgDhWNCM5QEJjDyVhTWn4gT1mQBCkeLCEqCX1NRc6cbL2FdL1qQgMIRiKAk+FUBOe3yIWCJBi+66Aq5lnFdkwWIArpmUBL8ahp32uVD03w0eNFFx7UEgkUggpLgV46I01wJclSiwYvcFq4lECwWvQMAAJ5i0TsAABALBCIxRoIkCsV7Jz/OERAMApEYYxKvYMSxQspXZt47+XGOSkscP8flgmTVGCOpLhhxHEWRr8y8d/KL0jnqGUyqs7tfHe0toQ4Rjko5ChHHz3G5IBCJMWa/DEaUKiSn8pWZ905+Xp0jLyrvqFSij2ztVdebw0pOTGrTl5eHVo5CxPFzXC4IRIA84lhpx7HMpcqLICIqlWja8m+c8JmILgIRIMbi3FReLrwIIqJSid63eqkaqitDD4hQWsp2HhG+wFEK1m7eped7DuqGtkWRqKgAQIrQPCLr16/Xhz/8YdXU1GjhwoW66aab1Nvb6+cuHSMjHqWAxdaAcDAKxzu+BiLbt2/XmjVr9Otf/1ovvviiTpw4odWrV+vo0aN+7tYRvsBRClhsDaUuqhU+N7PeCbRr5vDhw1q4cKG2b9+uFStW5H0+U7wDQHmLavcj3fu5uam/A01WHR0dlSSdc845to+nUimlUqnM72NjY4GUCwBKRalVkFEZMWQVlQTiUhDYzKrT09O66667dN111+myyy6zfc769etVV1eX+Wlubg6qeABQEkqty4Dux9IXWCCyZs0avf7669q8eXPW56xbt06jo6OZn4GBgaCKBwBFiUouA/lviJtAuma+9rWv6fnnn1dXV5eampqyPq+qqkpVVVVBFAmYodSasxG8qMx+SpcB4sbXQCSdTuvOO+/Uj3/8Y7300ktqaSFCRzRFpRJBfEU1lwGIOl8DkTVr1uiHP/yhtmzZopqaGr3zzjuSpLq6Os2bN8/PXQOuUImgWLREAIXxdfhuIpGw/fv3v/993XbbbXlfz/BdAFL5dp2V63Ej/iIzfDfCs8cDiJFy7Tor1+NGeWHROwCRZ+46K6dWAroMUQ7KdtE7APEU1Zk2rcopYAKsItM1AwBeMSr2Fa2NkqLfShCVbhUCIkQdgQjgEF/o4YpKxe5U0N0q2d6fcTtvKD8EIoBDfKGHK275EkEP5832/vTzvBGcwwuBTfEOREkh03EzdXa4orjmSCHvI7+mgje/P837MJ83r/ddauvaRGWa/nJDIIKyVMgXqJcVIV94paGQ95Fflbf5/ZltH17vu9SC81ILrOKCrhmUJbfN1V43QdPNUxoK6fYIoovJ2PaK1kat3bwr8771et9uup/i0I0Tt+6/UsHwXUD5vyS9HjIahy9lxF+UhjpHqSzwH8N3AZce2dqrrjeHlZyY1KYvL5/1eJh3kuWomEDNzyAvbgFklO7wo1QWRAuBCCApbfnXisAhWMV0XfnZ7RW3LrUovW+jVBZEC4EIIOm+1UvVUF3J3VpE5Lt7ztUy4eedN3f1gPfIEQE8EIUm+yiUIShe5huU03lzgvMBL7ipvxm+C1sML3UnCsP+olCGoHg5bLSczpsTnA8Eja4Z2IpbX3jYCm2y9/Lu0+9ugyjdKXuZb0B3y0zZzkeUrj9KC10zsMWXTjDiNKQxTmUtB9bPqN+f2VK8/nzP+YfhuygaGe7BiNPdeJzKGhV+VnTWVku/WzGDuv5BBge0/EYDgQgQAvOXbVy+AAlO3fOzorMGBn4HCkFd/yCDA4LraKBrBnDA67s0czN3R3tLpJuHS7n52u9jy7X9Uj6vxeC8lAa6ZgCPGF+KyYlJde89IsmbuzTznZiTO8Awv5xLufna72PL1YpQyue1GLS8lR8CESAHo7K4bsl8z4aLWoMKJ83DYVZapdx8XeyxFRMghnFenZSXFgkEjUAEyMFcWXj1pWwNKpzcAYYZDJTyHWqxx1ZMgBjGeXVSXlpqikcw5w6BCJCDH5VFIUFFKQcDcdUzmNTIxKTal8zPXMuoV0BO3nul3AIWFII5d0hWBYAC2M2rUYpzbcC9qAekQWCKd6AA5TStfdSPNerlk+ynmfdy6nnEl9GCWa5BiFsEIsBppbjGRrYKPerHmq18UQpQ7CqbUquAjPP97I6ByJx3lB5yRIDT7PrG497Emq2vekVro3bsG9GK1sawipZTtjyFQvrejWu4orVRXX3DvlzLKL1PvCiLddj6jn0jOjh6XFJ0cx6idA3gDi0iLkTpbgzes7ubjXrLQT7Zugq6+oZ1cPS4uvqGQyrZKT2DSd365Cu65clXZnyusrUsFNL10dndr+deG9L/2vKGnnttyJNraf0ucPM+8ft7xIv3rLGNtKQb2hbp7lWtke9yivtntZzRIuICmdDR5PZOyM3z4z6CINtomyisFiyd+kx1vXkqGGqorsz7uSpk9FBHe4t27BvRUPKY5p9dpeTEpHoGk0WV3/pd4OZ8xmFNGLth659b1lx02fzk9WeVFpbgMGrGhXJ4Y8bxGN2OVGBkQ+G8Pnc9g0k9srVXaUn3rV7q23vOeF+PTEzqV3uPFF3+Yj4nQa+a66Ys+D2+J4rDFO8+KYe5HOLY6uP2TijMVo64f/F7fe7amuq16cvLPdlWvv1860tXqmcwqYbq/qLLX8x3gfW1YX7m4vh5D0rcW0PjhBYRzBD3ijLq4rTYXTkL8nPgZXKp24RcPu/wC/OIoGClNvwwaszJlnEYouolJ8cVxLE72YdfiY92+/biM2eUd+O2Plfl5vOOKCAQQezFqeI2f/FnGwFiVwkGfYx+7M9J5R7EyAcn+/BrYjK/js8obxxGtwBW5Igg9sLu5y60WdzNiJYgjtHcTO/H/ozjWdHaqLWbd9mepyD65Z3sw2kOiPmcScrbzeHX8ZnLG/XRLYAVgQhiL+ykMqPS9mrSJ7tK0I9jtAZQxuRVfu3POC4jT0aafZ78TAg3Bw1e7cMcsEnKG7yVQ8I74BaBCGIv7C93852+0SLiNT+O0RpAXbdkfqZZ38v9WRMinQY5fsxZUkgrT65y2B2L9bi8HOob1GuBIBGIAEWKa7O4XQDlR4VlDQCcBjnFTOfuZbdPrnJYj8WunMV0cxmvTU5Mqr660tU1CrvLEnCKQAQoAYXc/QYVQBUaABTyOjdBg5tyJCcmtf+9o7r1yVd0r8uJ14rp5jJeMzIx6TqoCLvLEnDK11EzXV1d+vSnP63FixcrkUjoJz/5iZ+7QxnzYpRHnEbfWEV5nY1Ch4i6eZ1x7Va0NroaNeLkmrc11au+ulK794+q683hvOfYus1ihsgar71v9VLXo2G8GJob588E4sPXQOTo0aO6/PLL9e1vf9vP3aBM5PpSdFoRe7GNKCp0uGmpVDTGtevqG3ZV+Tq95h3tLfrjSxq14pLGvOfYy/eRcX0kFR1UFCLOnwnEh69dM5/85Cf1yU9+0s9doIzkanZ32gxtrMS6Y9+IHr/5qhlf7FFuys7X9VJot4PfeQRBJUz63f3T1lSvHzicit68zWKP3+s8GbcKOa8kycKtSOWIpFIppVKpzO9jY2MhlgZRk+tL0WlFbF6JtbO7f8Zrgho6Wsjoh68+vVNDyWOSvA0Y/A6+vAp0/ArEcr2u0Gtm3mauocpOZLs+ucrmZXBZyHklSRZuRWpm1fXr16uuri7z09wcnxEI8F8xfd7mJu7Hb75Kn758caAtH8U0cXd292soeUyL6+f5NhFWrnNaTPeNky6joKZcd3scXuyz2Blas12fXGXza1ZYpwrZf6l0EaIwkWoRWbdune65557M72NjYwQj8IT1Li3oJeC9GDkR1jLxxbTGOLmjdnIH7UXLjds79Vz7dPoecNOi4OZ9VWzroJ/dJ7SiwK1IBSJVVVWqqqoKuxgoQV52QRTypVlMF0CYE7b52Rpj8HLK9WL3Y8h3TfyoON1ss9jzEbWKP8r5WfBfpAIRwC9eVuZef2k6qRSCSAC020cQrTFBBVpu9pPvmvhRcQY542zUKv6wZ0dGuHzNEXn//fe1e/du7d69W5LU39+v3bt3a//+/X7uFvCV10unO+lT92oYpdvhy1FeJt7LvALrtrJdk2KG09qV1/w3p+e6kPeCl3ObAF7zNRD57W9/qyuvvFJXXnkq0r3nnnt05ZVX6sEHH/Rzt0CsOKkUvEpAjHKSo1W+QMM4lke29to+L9frrY85rdyLTTq2vraQ7RVynbyeD4TkUnjJ166ZlStXKp1O+7kLoCx41XTtxRDooDjtHsk2/Xmu12/Y2qtfvjmskYlJ/eDLy2edl2yv9SrpuJjtFXKdwuhOBJxKpCMcKYyNjamurk6jo6Oqra0NuziAL5z2+cdlJdZ8+zI/LmnWc43HnS7Gl21/ucpx65OvqOvNYa24pFGbbCYqY1Ku3Dg/yMdN/U2yKhAyp3eXXqzimu21XlYs+fZlflzSrOeaH+9ob9EjW3uVlnRflsXmsrUQ5Go5uHf10sxqtnbCHgIbdX5MBIfyRSAChMxps7nX3QJmXja159tXri4K6+Od3f3qenNYktRQXemobE4qwkK7oczbtgZM5VD5Ojm3fnTbENyUNgIRxEqYX0iF7NuLStG8jUK/2Nua6nNWll7mEOQ7Huvj1ueaH+9ob1FyYlJpF2XzsiK0Xj9r8CFJK1obPZ+C38/3eTHbDmryuUL2i/iK1BTvQD5hrgZayL69KK9Xx5xrO06HcwY9WqKtqV6bvrxcP/jyclez2Ho1+sd6zszbNs5ZV9+w55O+5bpWbkYD2f29mPeTk3NrXWvHi/dK1EZ0wVu0iKAoQbdQhDkRUyH79mI2T6+OOdt23FxDuzvTqN29ezX6p2cwqYH3juqcsyq1orUx67bdTvrm5JhyXfNcrQPZHrNrySnk/eTlpHB+7RfxQyCCogTdZBrUF5JdZVHIvr344vbimL1ardWuEvPzPRDE+6tnMKkNW3uV0KkkVuP8dHb3a9f+UUlSV9+wPrfMft0rt9fHyTHl2mauQCLbY9ZgKYjPUNRmb0V0EYigKKX6ZRNGn7SRDzEyMZmZadMruY7HzTW0q8RWtDZqx76RTKtBPl4t7ma3nUJaUMwJsZIyw3k72ls0MjGpRJb95+NXC1euQKKQEUR+oRUDTpEjgqKU6lTRufqk/cqTaGuqV311pX6194jnOTC5jqfYa9jVN6yDo8fV1Tec/8lyl/+Qq2zFzlRq7GtFa6MW1pxabNM8qVJbU71+8OXl2uQiPyVf+fIdk1+YCRVRRiAC2HBbAVoV+sXvV1Jevsqv0PL2DCaVnJjUdUvmZ8qcb1srWhu1qG5upgWl0ERKu3Pl5vwZ++rqG9b3br1an7lise5bvdTBUTvjZ4Kl2+sVVJJ3mAEPwVZ80TUDuOSkab3Qrh0vm7OLTUJ1orO7X917j+iGtkUzcitybcvcgvK5Zc0FJ1LanSvz3/Idvx95E9Z9+tU14fZ6BdWFGuYwW4b4xheBCOADL7/4Cx2VUkwSqtN95pqcLFu31sjEpNpNLSjWgCDbfCduz0Nnd7+ee21IO/aN6O5VrZnp4o3Hss3L4vc8G7kUc95zKYcE1VLNVysHrDWDkhLEcOK1m3fp+Z6DuqFtUSBf7oXur5hz4fUxGmUZmZjUr063oGQLAozJwT59+eIZz3FbJvO2FtfP08HR47qhbZEk5dxOMcde7Psv6PeW35gRtXyx1gzKVhDNs0HfeRW6v2x3wYXOY+GmUsk2I2n7kvkz8ibsnpdtcrBCWgEev/mqWQvoWbfn5NidKnaNmlK7qy/17hICLW/QIoLYy7eaa77XBD16IewvrkLvut28zvrcnsGk7eJ1ds/zolvGjl/n3u12/Wz1iML7K8rl8VqptWB5iRYRRJrXX07Wuy4nXwhh3alF4Q6x0LtuN6+zPtcYmvx8z0E1VPfPWEvG+jzreTG6WA6MHNOOfSN6/OarZswbkm91XoNf596rxFEvPhf5yhJ0YFDqc4mUWgtWWAhEEDivK4R8XwZ2X75hfYF4td9iKpQgKgdjH8aQyo72Fttjd1IWo7tmbuUcHRg5pq8+vTMTjJgnI8u3Oq8xQVnS4wnjvEoc9eJzka8sUQiES0mpB1pBIRBB4LwOAvJ9Gdh9+Yb1BeJmv15Ny16MbMve59rnszsGtHFbX2akitvWKivjfbKitVEbt/VpKHlMnd2nWlU62p2vztvWVK+G060y9aZWGTe8mvrfjhefi3xlicJoLsCKQAS2/PySCToIiGvzqVfTsntVBqctChu39Wlw5Jg2buvT4zdf5aicud5v5vdL67k1M/KBjNV5nSq2VcTPADDIliqp+M84rSvwCjOrwlZQMzEGIa7T0He0+zctezbW2SmNMqxobcy8F7rzTEF/96pWNTXM092rWh2X0+79ZjdTpt323MyoabSK5DuGbHJdk7AUOqNosZ/xKJ6LsDG7a2FoEYGtuLYilJIwuo+sd7lGGYzRAdbht3Y+t6w560q1ZuYuHLv3m9M77iBnGQ1z9edsCm2ZKPYzTn7EbLQSFYZABLb4kokXr7rSslVO1tlPvWDuwum+/2MFdz9FdZbRYhQzK65Tfk1rX864gSsM84ig7JTiF2e2+QyifKzmFhEnLSjlJMrXzYq5NGDHTf1NjgjKjp+r54YlW399vmP18jjN28q2XfPfP7esWd33fyxSQUhUrnuc8prIFUGx6JpB2XHSfOqmaTwKd6/W0RAbtvYqIenGyxdLCmZeCfO2JNlu13jOyMSkGqorCz5n1taUXNfAzWP08bsXh64uRBuBCMqOky9ON329Uau8Orv79cvTk3zVn67svVjbxFppW3+321a2XJPkxOSMYcFuAzlzfsnnljXnvAbWIci5Ag/zMUQhwATKATkiQJGiVmGZW0TuXb00U9kW24dvzQXIlxvgpCXCPEmZsdquk/NptIh8/qoPqP/IxIxF7czTvxv72PLakBKnX9ttWv03174KWe03Su8DIEysNQP4IFtF42XTtBeVWVtTvX5gmuTLq0x+63bcTCdutESYA4ZvfelK3fLkKxocOaYFNVWZVoiOTb/V4fGUXn7riL5369W258EYImwEC1LulhBjRtXrLMOPc03wZZ7Rde3mXbbBTrb9RaFlLM4I6soLgQjgUBAVjR/7sFv3xa5rxel2sv1uZQ5UjOPasW9EB0ePSzp1fAlJCUl/uKhGkvTVp3fq8HhKkvTueCozlbuZudy5giHrYyMTkxo/fjJrefPNoWIte779FYIK+BSCuvJCIAI4FMQcAX7uw/rl7tWXvZOWInPrgtGqIJ3qOqqvrtSK1kZ99emdGkoe08KaKjU1zNXZc8+ccR6M/YxMTOpXe49kyp2t7OYArLO7XwlJu/cnJSmTKJsvxyVX2a3nwOgOK4aTa1IOwQrzcZQXckSAEpGvguoZTOqRrb1KS7pv9VJJypl86lShuSLWBfWee21Ii+vnZRbLsz7fPLtrvYsRN8brrlsyXwkpc/xe5c4Y+/jp7iFJ0o1XLC54e06uAfN2IA7IEQHKUL676bametWfzpVoOL36rN3Q2myvtzIng0q/z6WwVqLZtmv++4rWRu3YN5IJQp57bUj/9dYR/cGiGt23emmmxWJkYlJS/hles3XfmAMuo9xe3HUbZUuYtldIYOf1iC4gDghEEGml3gxdyPFle42TCspNTkW+MhhdKZJm5FIY28iXx2HNITk4ejzTErJj34gGR47p8HhK7x8/oX/9antmwbrnew5q7PgbOjyemjUrq3Fu9r93VLv3j2pkYlI/+PLyogIuJ6wJwoXux8n7ganZUWoIRBBZdpWdV9uNyhdwIZVVttc4qaDyPSc5MakNW3szrRC5yjCUPKbF9fNsR9FYy5ithcaaQ2Jck8dvvkpf+O7LSp2cVt+77+uK/3urEpJuvfYC3dC2SC+/dUTvjqf0jRd6Z3TjGPudf1al0pL2HBxXz2DSVcBmbjHJNUomn2z7yfX+CzJJk4RQRAWBCCLLrrLzartR+QIupJndaUXqtgLt7O5X1+mJ0BqqK3MmSyYnJtXe2jgjYDG6T9x2e5grfvO8HxfOr9Z7Eyd0YmpayYkTkqRndh5Q9/0fy8wjsqCmSs+9NqQd+0b0+M1XzUgsNeYnsY68yTaKyHwenIySySdb0Jfr/RdktwtdPIgKAhFElvUu2Y/thq2QZvZ8rym0S2BkYlJXnF+vmrln5Dw3nd39mUnBvLij37C1V798c1gvv3VER45OZrplJKnqjAr9jysX6z/eOKTjk1M6NHZcj77Yq7v+dGlmanej1cwIOIxgyJz0mu047MrqZJRMIZzkprh9PxTTusfU7IgKRs0APgqyG6iYLoVbn3xFXW8Oa8UljdpkyXXItp9sM6Zu2Nqr94+fUM3cM3WvqcUk2+uu37hdvYfe1wXnzNOFjWdp7PgJ7T30vsZTU5KkioT0xaub9P++OihJOnNOQtdePD8zc6w0c/SP01ElQXfROSmX0zJZhzIzggZRw6gZIAR2lUgYff7GgnJupE///Pq/39OzOwZyroibazZSI6HUvNaN8dzO7n79dPeQtv5/h/QXf9yinQNJJaRMDtDQ6HFd0HiWegbHVDv3DEmnApHptLT5dBAinQpMjC4kYx/mc76itVEvv3VEew6O6ZYnX8ma72LtSjIHb34EKeaWuGzbd/p+MZ7XbpkpFoijiiB28u1vf1sXXnih5s6dq+XLl+s3v/lNELsFAmVUDp3d/Zm/dbQHt0S6sa+ENKsc+Xzm8sWaU5FQ6uS0Nm7rc/y6bMf8x5c0asUljTOOu6O9RXMr5+jY5JT+n1/sVdebw9r+5rCmTjfKnphKKyHpuiXzdXJ6esZ+zM22qZOnfptTkdDY8RN6vuegHtnaq7Wbd6lnMKmuvmEdHk+p99D7+uWbw5myGTkhPYPJWeXfuK1vxnHYHZeZdVt227YyAjhzUq2x/Wd3DKj9G79Qy/xqR+8X41rfu3ppZptAXPneIvKjH/1I99xzj7773e9q+fLlevTRR3X99dert7dXCxcu9Hv3QF5e3f3a5Z4U0w9f6BTsPYNJ1Vf3285Kmm1bXX3Dmp5Oa17lHN29qtVxGbMds3Uoq/H3//2ZD+p/bXlDxyanMn+fkzg1H2nlnITeGT2u9yZOaPz4qcerzqjQebWV2vfe8Vnbm5pOq3bumbqhbZFGLKv5GtO5m/Nd7FobsuWD2B2X3UJ9xrbctnxZt2+sJmwk4+aTL+E2SqI0Sg3R5HuOyPLly/XhD39Yf//3fy9Jmp6eVnNzs+6880498MADOV9LjgiCENWZKr0sV74cEK8qC+t27LZr5JH8bnBUIxMndNX5dXp3fDKToCpJ1ZUVOjGV1vyzztS745OaTp9qvp1bOUcTp4OYOQnpzo8t0cf+4NycM8balS3bc3IxrseiurmZ0VyP33yVJ105xigg67woTssUtfeuWRzKCO9FJkdkcnJSO3bs0Lp16zJ/q6io0KpVq/Tyyy/Pen4qlVIqlcr8PjY25mfxAEnRGkVj5uUw3bTlXyuvRlDkW8/GKPN9q5eq79C4Nm7r083LL5Akff2FXo0dO6HUyWmlTkxrKi29MzaZ2fa0pKsvbNCeg+N6dzylqfSp4bw7B5L65ZvD+uNLGmckqxr7tDvGXKv2ZmPXemIeulzMwoLGasJW+V7vdhK6MFomovr5QnT4GogMDw9rampK55577oy/n3vuudqzZ8+s569fv14PP/ywn0UCZonqMEYvh+net3ppZqE3r+VaDdeaoGkMtd2xb0QXLzgrM5uqJB15//c3IdNZIqZ9w0f1gYa5evf0Cr2jx07o0Om5Pt4/fkJrN+9yNIeJOaiwdm04WcQvW6uF1wsLOpm2v9iJ8PwW1c8XoiOQZFWn1q1bp9HR0czPwMBA2EUCIssuEdacNGn+v7U1IFdSpVW+RExz4qU5IVOanaA5lDymqjPnaCh5TGlJN7QtUsv8ar381hHVzTtT02llFqarOqNCVWckZuxr33vHVDv3TDU1zJMkjR8/qbePTGjFJY2qmXumnu85qK6+4bwJnEa5uvqGZyWl5ktUzcV6TQpJVjaf72KTnb3cFuAXX1tEGhsbNWfOHB06dGjG3w8dOqTzzjtv1vOrqqpUVVXlZ5GAkmF3p2m+65U06w44211xvmnHzbOXWh/PldhpzscwL45n7tpo/8Yv9O54SlVnVGhhTZUOn/5/6uS0KufMDEQuOGee7j3drfM3W17XxOS0UienVV9dqRWtjXrr8NHMfvIdV7ayF9OVYL0m5iHCTrtEnEyP75SX2wL84muLSGVlpZYtW6af//znmb9NT0/r5z//ua699lo/dw2EwskwTj+Z73rt7oCz3RXnagXoaG/R4vp5mdlLra0udpXsQz99Q1t2D+mhn76R2bbRUvG5Zc361peuVN+hcbV/4xf64yXzM4FHU8Nc3XjFYn1wcY0kaXIqrQpTLDJxYjqTWzIxeWqI77zKOepob1FX3/CMrp58xyXNbLExjkvSjBYVJ9c013PctrB0tLeofcl8jUxMFv0+ohUEceD78N177rlHt956q66++mpdc801evTRR3X06FHdfvvtfu8aCFyufvggkgWtd+R2CZR2d8W5WgGMReiMsmdrdTHf+R84PQLmwMgxPXzjB2ds2xghcjR1UiMTJ7Rtz2HVzjtTh8dTOpo6qa43D+vk1LRqquZoPDWlisTvc0YOj6f0V8/+TtPptGqq5mhyKq2bLl+kR7b26p3R45p/VuWMFhE3rRvZrp2T3Aov149pa6pX/elVhhuq+4tqxSA/A3HgeyDyxS9+UYcPH9aDDz6od955R1dccYVeeOGFWQmsQCnIVem4TRYsJHApdHbXfBVWtpVyDdYA5f5PLM0MR7V2TxhzZlRXVqgiIY0fO6HjJ6e1sKZKIxOnghNJWlhTpbrqyhnDeqVT84ckJJ0xp0JHJ0/ol3uP6MDIqZyThE7NiWIkk7qpiLNdu472FiUnJjMtFLm6eOySX7OVIdf1ZaQJyglrzQABcRtY3PLkK5lhqXYThNlZu3mXnnttyNM5Loyyb9jam1nfxW472ebpkJQZLfPpyxdrRWujvv5Cr0aOpnTSNIHqn1zSqCub6/X4S2/pjIqEli6q1f+1/Hz90yv71XtwTJNT6czsr4amhnm6e1WrfvrakMaPn9DZc8+cMaW7eX6O1nNrbOc0cXJunM6F4WbODD/m12DyMERFZOYRAfB7bpvJE5Z/rewqnY72Fu3YNzJjNVovmuc3bO3NrO9iXj/GrK2pXitaG/XVp3dqQU2VegZHM48ZE4AZZe3qG9aW3UOSpOrKObr6wgbdePlibdzWp5PTaS2snauewVF1nTOs88+p1u79SaUlnZxOZ/JJGqrP1EULzlLruTVZJ2kzZnHduK1Pyy5ocJy8a+W0hcJNS4YfrR5hDdEFikEgAjjk992mdfv3rl6aWdDNjrnSMXd9PH7zVXpka2/OrgS3x2IEQwtrqnJWnEa3y9HUSS2qm5vJ19ixbyTTTfPsjgG9/NYR1cw9Q+PHT+rDFzZo05eX65YnX9HgyDFVnVGhz1/1AfUfmcjsa2RiUodGj2lk4qT+5zXN2jmQ1P85OK7uvmE1ZAmMOrv7lToxlZm2vvXcmsy5MjgNBqwL/Zlncs0214jx3FwzzXodLNClgzgiEAFshLGSrnX7+Soqc6VjfW2+ZEe3x2IOinIFLnevatXGbX2ZFhFjBMtQ8lhmMT2jlWJhTZU+dunCzHGMHz8pSUqdnNYzOw/o8ZuvypT1M6dbS4bfT+mZnQd08YKzdOT9lBrPrsoacJnPj/GY9VjdBAPGe2JkYjKzunC2IMjg9QRn+ZCcijgiEEEg4tZ3nWuBNL/uNgsZXZGtbPm25WRfhdy9G1OVW/NFjO6ijdv6Mq0U939i6YwZShOnJ6CvnJPIdC1Jp0blGK83JkO7aMFZ+vTlizXw3lH98s1hJaRZ3TN2ZXaS65KN8Z5oXzJfKy5pVFruu2posQBmI1kVgYjbwldhB0659h9U2eyuWaH7Nq9c29U3bLtei5Gce8X5daqZe6beP35C6cw8qwnVzD1Dn7l88cxVcjf9VofHU1rhMKF37eZd+unp3JQbr1jseFK3Yo4dKEckqyJy4nYnGEYTt7miy9WEH1RCot01y7dvp+u02C06Z14Pp7O7P9P98YGGeZlk19ZzazKtKLc++YoOj6e0oKYqs+quk2MamZhUQrPfi16s6xJEsEJAhFJDIIJA0HednzX51PyvmRdBXbbKzPp36/Tk+fZtV5lnG91j3Y61q2lkYvJ03khakyenM901xvDf45Onckr+YFGN4wq5rak+a8uJF+c133T4XmBkDEoNXTNARAR5p5utq8z4e/uS+aqvrtTIxKR+tfeI4y41u2MoplvOeO11S+ZLOjV6p2dwNDPpWVPDvExSqzX3I4zuLfMKw5++fHFRgYLTYNGr7QJeomsGcCBqX8hBthrlmkVUOjVc1ghI7NYqybaonTXvI9e+3JbTaAmomXvqa6uh+sxMq8PazbsyXTnGPCeFdm8V876wTodfjGxlLPZ9QosKooZABGXLyRdy1IIVr2SrzIy/9wwm1VCd/W48OTGp7r1HMn83RrYcHD0uybuK025kkF3AY5f7UWj3Vrb5Wdx0/3hRwRcSwDl5v8YtXwulj64ZlC0nX9pxG+3jhnUki5PK1txV0mCabM1uO3EN4uyShr2+/n6dG2vXWtzOPUoHXTOAA07uXKNw91hMpZXrtUYla7RkjExMZoILJ3fT5ueYR8RYt29+3Fq2DVt7NX78pBJKz1onxs2xeFmx51vgzwt+dY9Yu9a83j7gBwIRIIcg8jbyVaLFVFrW15r3Ze3qSDqovNwMYTWmd881wsZYv0Y6lYhqnqnUel5ydZnkG62SbUG+fEGL2+vvNCDyK8Cx61oDoo5ABAhZvkCjmEprRWujduwbyQQF1n2ZWzJ6BpOq96Dycppj0dHeopffOqJ3x1NqqD5TH2qqU0d7y4yp1H+190impaZlfnVm/RrrcXS0/36xv0e29s7qljA/X5JvrQVOg0a/A1yGyyNOCESAkOULNAqpVMyV+cHR4+rqG9bnljXn3Feu/bjp+uhob1FyYlIjE5N6ZGtvJqnVbp2X7916ddbhvsaIHaOlZlHd3MyxWI/DPFrFrlvC/Py+Q+N6+a0j2v/e0ayLAhYqCl15QNyQrAqUIK+TFq1Ju/kCE7ukVqd5Hdb1YPoOjWvjtr4ZK/LmOpZ8uSRffXqnBkeOKaHZ07zDubgmIyMYJKsCZS5bUqlUWAVivdN3251kt79c82Q0nF49uL761MJ3B0ePa9dAUvXVlZnnPbtjQN94oVcfaJirh2+8LLPtXC07nd39Gkoe04KaKv3BopoZXUG5zofTc+ZmJFLcK3LmI4FXCESAEmStjJ2uY2M81zpLqXV7brqT7NaVMV5rdOFYu0jstm/tctm4rU/vjqf07nhKnd39jipDuwAtW/nM58OYLTXbcwzmkUhDyWM5p3qPe0VONxS8QiCCshD3u89iOV3HxniudZZSKzd5K9n219ZUr/rTLR8N1f2zWkXMv9uNBLl7VWumRcRpZWhXbifnw1h0b0Vro9Zu3pX1fWQeibRxW19mfRyvk5ALUci8MbmQEAuvkCOCslDKE5M54SYQs2sR8WI/dtsNMkAsdF9OJzizbj/X75LzIcReHZfxGTCSfsv1s4BgkCMCWJR7M7Kbu9dcK9TmY1TUxnTraSkzSZldS0uuLiSvAxWnXSHWfTqd4My6feux+TWE2OlxWeeNKdfPAqKHQARlgWbkYLqnjMotOTGZmazMmKSso332ejDW8llzMdzkUeQLYpwGo7n2aWzH7jzabd9uAjnz44UGA/m2a8f8GTDPgAuEjUAEZSfK+SJejuCwylbB+jE9es9gUpI0fvzEjGTUXC0t5lwMa+XqpMK2Hl++FgrJ/tit+8w1w2u+xf2yTSBnfa1bubYLxA2BCMpOlEcr2JXNaUWYT7ZKvZjzkS2IaWuq172rl+qrT+/U7oHRGVO3Oymfk6G4uV5v968du2PP1aVitOzk2262Mnml3LsaUVpIVkXZiVuLiNvJxLzYp9PnG2u8NJ59al4Oc3Lr2s279NxrQ6o6c47+92c+GMnuADctUF6NNsFMUf48onBu6m8CESDiovZFbZ41VZL+z8FxHR5PzZqp1Jzz8enL4z+DqZORV8/uGNDGbX26e1VrJAOvKCr3EW2lilEzQAmJWqKtOSG1e+8RtS+Zr/SimllJqOb1X/zoQiimJaeQgM5Jd8jGbX0aHDmmjdv6MoFI1ALJqKGbCbSIAKeVQoVRzDEEXbEXy3wnnW0kS7bn+xXY2bWIhHHH3zOY1CNbe2cMnw5K2O8LRAMtIkABopzE6lQxx+D2tU5bavyqmMxTxG/Y2qtfZVnl1/x8879Oyum27J9b1jyrSyaMO/7O7v5Zw6eD3HfcP0cIFoEIcFopNBEbc3UkbdZvcfJa879uZau0vaiY7LZtniK+fcn8TMtINvkCJ7tyelH2QrrWvOhGSk5MKq3g38+l8DlCsAhEgNOilotRCOvKtW6Op9jj37C1V11vDuvlt47oe7denXVejkJY18qxm8yr0FYMQ64Jx4KuVIsNgNqa6rWpwNlxi1UKnyMEi0AEKEIU+8PDqjwTp/+1roZbbMXUM5hUcmJS1y2ZP2O9l5GJSTVUV2Ztgcn2eDZ25XRSdj/eA15cwyi+NwE7BCJAEaLYHx7WHem9q5dKkufdAZ3d/eree0Q3tC2aMVV7cmLS9twb3VN7Do5r+P3UrMe9ZsylsmPfiB6/+SpPKv1s19BNcBHF9yZgh0AEKEIp9YcXO728X90B1nNsnka+vnr20GCje2r4/dSM6eKLkeu4O9pbtGPfiIaSx2a0BPnBTXBRSu9NlDaG7wKQ5GyYaVwmn/K6WyLfcQfVDUJ3C+KCmVUB+DIviBfzlBQyVXq+/fpdQRMAAO64qb8rAioTAJ/1DCa1dvOuzMq3RjN+Z3d/3udKv+/yaGuqt33c+hy3jPJs3NaXtVy5Xvvca0P66tM7M2UylzHXsXrByE3p7O6fdU4AFIdABCgR1sq4o70l69wa1ue6CWKcsm7TKM/dq1rzzvlh1dHeosX18zJ5GNYy5jpWr3gV7GQL8sIUxTKhfJCsCpSIbEmdTp5bzFL32Vi3aS6P2wXhjHVrHtnaq5HTk7WtaG3Ujn0jWtHaGMgsr14lf0ZxNEsUy4Ty4Vsg8rd/+7f6t3/7N+3evVuVlZVKJpN+7QqA3A3btT7XTRDjlNejNswzqTZUn2qVODh6XF19w44Dm2IqXK+GRUdxNEsUy4Ty4Vuy6kMPPaT6+noNDg6qs7OzoECEZFWgdGVrnegZTGrD1l4ldGpuEutj5tV83bZuWBelc9NCQsIq4FwkklUffvhh3X333frQhz7k1y4A5BHlvv9sORed3f365ZvD6npzeNZjxSTLSlJX33CmFSVXGcyMc/jI1l7Hzy32fEf5ugFei1SOSCqVUiqVyvw+NjYWYmmA+Aui79/LtV2M30cmJpWwecyskGOz7tNJl4Sxn+scLKzn1fkmZwPlJFKByPr16/Xwww+HXQygZATR919opWmeIXXt5l2ZQKatqV73rV6ad3RKIcdmt083M5RaAy1rEObV+SZnA+XEVdfMAw88oEQikfNnz549BRdm3bp1Gh0dzfwMDAwUvC0AxXdlOFHs0Fm77pF8XSbF5mu4GYqb6xxat+PV+Q7iugFR4apF5N5779Vtt92W8zkXXXRRwYWpqqpSVVVVwa8H4L18lX6xo0ns7v7ztQjkaoVxEqTQcgFEh6tAZMGCBVqwYIFfZQEQQV7mK9gFCXaBTL7gJlcA4KS8Xg3FDWulYwMjeVAKfMsR2b9/v9577z3t379fU1NT2r17tyRpyZIlOvvss/3aLQCPub3rz1U5FhPUWLfrdLK2sPkZLJDUilLgWyDy4IMPatOmTZnfr7zy1IfkP//zP7Vy5Uq/dgvAY27v+nNVjsUECU4r3bBbKawKDRaC7GICwuRbIPLUU0/pqaee8mvzAHzg1eq60uzKsdiWgbhWuoWWO8guJiBMkRq+CyBcxTT153ttsd0IbirdKOVOFBosxDXwAtwiEAHKhN9N/fleG2TFWgq5E1Fv7YhSsId4IxAByoTTIa+FVn75Ks4gK9awWxPKoZIuhWAP0eDbWjNA3JXaeh+5Jh5zM8FX1Nhdp7AnBIvz+XSq2InsAAMtIkAWpXbHF6chr5LzVgU/rlO5Jta6EfWuI8QHLSJAFuVyxxfVbgS7VgW71g8/rpPTfWcTdosMECe0iABZeHHHF9VK3iyqLT92rQp2ZfXjztzpvgEUj0AE8FEcKi8n3QhhBFR2AUZQXR5h7hsoNwQigI/iUHk5aVEwAqqRiUk1VFfaBiRBBCvkJQClhxwRwEdB5gq4yWFwOyLIyMNISFlHg2QbKVIqo4/KYSQMEAZaRIAS4aYbyG2XkRFQ9QwmVV/db9vCk631J6juKb9bZOLQugXEEYEIUCLcVJSFVqq5ukayPRZUBe424HEbuNAtFD1xSAZHfnTNACXCTTdQkF1GdvuydtfYdd8U2n3kNOChqyX+uIalgRYRAIGztl7YtWYU2n3kFF0t8cc1LA0EIgACZ61A7CoUvyuZcuxqKbWujHK8hqWIQARA6OwqFCoZ78VhXhuUH3JEAATO2rdfKkN8o65cli1AvBCIAAictULMlXQYhyAlDmWUWAMH0UQgAiBw1gox15261yMj/Agagh69EZfAB3CCHBEAoTPng1gTKr1OWvUjTyLo0RvkeqCUEIgAiBRrJet10qofQUPQibUMW0UpSaTT6XTYhchmbGxMdXV1Gh0dVW1tbdjFARAAr4aYltpQVSBO3NTftIgAiBSvWhfovgDigUAEQEmKQvcFrTJAfgQiAEpSFCZEo1UGyI9ABAB8EoVWmTDRIgQnCEQAwCdRaJUJEy1CcIJABCgR3H0iasq9RQjOEIgAJYK7T0RNubcIwRkCEaBEcPfpHK1HQHQQiAAlgrtP52g9AqKDQARA2aH1CIgOVt8FUDaMVWslzVj9F0B4CEQAlA2jS6azuz/sogA4ja4ZAGWDLhkgeghEAJQNEnqB6KFrBgAAhIZABECojATSnsFk2EUBEALfApG3335bHR0damlp0bx583TxxRfroYce0uTkpF+7BBBDJJAC5c23HJE9e/ZoenpaTzzxhJYsWaLXX39dd9xxh44ePaoNGzb4tVugpJTDDKAkkALlLZFOp9NB7eyb3/ymvvOd7+i///u/HT1/bGxMdXV1Gh0dVW1trc+lA6Jn7eZder7noG5oW0SSJYDYcFN/BzpqZnR0VOecc07Wx1OplFKpVOb3sbGxIIoFRBatBQBKXWDJqnv37tVjjz2mv/iLv8j6nPXr16uuri7z09zcHFTxgEgyhpuWarcMALgORB544AElEomcP3v27JnxmgMHDugTn/iEvvCFL+iOO+7Iuu1169ZpdHQ08zMwMOD+iAAAQGy4zhE5fPiwjhw5kvM5F110kSorKyVJQ0NDWrlypT7ykY/oqaeeUkWF89iHHBEAAOLH1xyRBQsWaMGCBY6ee+DAAX30ox/VsmXL9P3vf99VEAIAAEqfb8mqBw4c0MqVK3XBBRdow4YNOnz4cOax8847z6/dAgCAGPEtEHnxxRe1d+9e7d27V01NTTMeC3DEMOCpcpjXAwCC5FtfyW233aZ0Om37A8QVs4ACgLdYfRdwgXk9AMBbBCKACywjDwDeYhgLAAAIDYEIAAAIDYEIAAAIDYEIAAAIDYEIAAAIDYEIAAAIDYEIAAAIDYEIAAAIDYEIgFl6BpNau3mXegaTYRcFQIkjEAEwC2vqAAgKU7wDmIU1dQAEhUAEwCysqQMgKHTNAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAACA0BCIAMipZzCptZt3qWcwGXZRAJQgAhEAOXV29+v5noPq7O4PuygAStAZYRcAQLR1tLfM+BcAvEQgAiCntqZ6fetLV4ZdDAAliq4ZAAAQGgIRAAAQGgIRAAAQGgIRAAAQGgIRAFkxhwgAvxGIAMiKOUQA+I3huwCyYg4RAH4jEAGQFXOIAPAbXTMAACA0vgYiN954o84//3zNnTtXixYt0p//+Z9raGjIz10CAIAY8TUQ+ehHP6p//ud/Vm9vr5599lm99dZb+vznP+/nLgEAQIwk0ul0Oqid/fSnP9VNN92kVCqlM888M+/zx8bGVFdXp9HRUdXW1gZQQgAAUCw39Xdgyarvvfeenn76af3RH/1R1iAklUoplUplfh8bGwuqeAAAIAS+J6vef//9OuusszR//nzt379fW7Zsyfrc9evXq66uLvPT3Nzsd/EAAECIXAciDzzwgBKJRM6fPXv2ZJ7/l3/5l9q1a5e2bt2qOXPm6JZbblG23qB169ZpdHQ08zMwMFD4kQEAgMhznSNy+PBhHTlyJOdzLrroIlVWVs76++DgoJqbm/Vf//Vfuvbaa/PuixwRAADix9cckQULFmjBggUFFWx6elqSZuSBAACA8uVbsuorr7yiV199Ve3t7WpoaNBbb72lv/mbv9HFF1/sqDUEAACUPt+SVaurq/Wv//qv+vjHP66lS5eqo6NDbW1t2r59u6qqqvzaLQAAiBHfWkQ+9KEP6Re/+IVfmwcAACWAtWYAAEBoIr36rjGgh4nNAACID6PedjIwN9KByPj4uCQxsRkAADE0Pj6uurq6nM8JdK0Zt6anpzU0NKSamholEomwi+PY2NiYmpubNTAwwPwnEcU1igeuUzxwnaIv6GuUTqc1Pj6uxYsXq6IidxZIpFtEKioq1NTUFHYxClZbW8uHMuK4RvHAdYoHrlP0BXmN8rWEGEhWBQAAoSEQAQAAoSEQ8UFVVZUeeughJm6LMK5RPHCd4oHrFH1RvkaRTlYFAACljRYRAAAQGgIRAAAQGgIRAAAQGgIRAAAQGgKRgKRSKV1xxRVKJBLavXt32MWBydtvv62Ojg61tLRo3rx5uvjii/XQQw9pcnIy7KKVtW9/+9u68MILNXfuXC1fvly/+c1vwi4STNavX68Pf/jDqqmp0cKFC3XTTTept7c37GIhj69//etKJBK66667wi5KBoFIQP7qr/5KixcvDrsYsLFnzx5NT0/riSee0BtvvKGNGzfqu9/9rv76r/867KKVrR/96Ee655579NBDD2nnzp26/PLLdf311+vdd98Nu2g4bfv27VqzZo1+/etf68UXX9SJEye0evVqHT16NOyiIYtXX31VTzzxhNra2sIuykxp+O7f//3f05deemn6jTfeSEtK79q1K+wiIY+/+7u/S7e0tIRdjLJ1zTXXpNesWZP5fWpqKr148eL0+vXrQywVcnn33XfTktLbt28PuyiwMT4+nm5tbU2/+OKL6T/5kz9Jr127NuwiZdAi4rNDhw7pjjvu0D/+4z+quro67OLAodHRUZ1zzjlhF6MsTU5OaseOHVq1alXmbxUVFVq1apVefvnlEEuGXEZHRyWJz01ErVmzRp/61KdmfK6iItKL3sVdOp3Wbbfdpq985Su6+uqr9fbbb4ddJDiwd+9ePfbYY9qwYUPYRSlLw8PDmpqa0rnnnjvj7+eee6727NkTUqmQy/T0tO666y5dd911uuyyy8IuDiw2b96snTt36tVXXw27KLZoESnAAw88oEQikfNnz549euyxxzQ+Pq5169aFXeSy5PQ6mR04cECf+MQn9IUvfEF33HFHSCUH4mXNmjV6/fXXtXnz5rCLAouBgQGtXbtWTz/9tObOnRt2cWwxxXsBDh8+rCNHjuR8zkUXXaQ/+7M/03PPPadEIpH5+9TUlObMmaObb75ZmzZt8ruoZc3pdaqsrJQkDQ0NaeXKlfrIRz6ip556ShUVxOlhmJycVHV1tZ555hnddNNNmb/feuutSiaT2rJlS3iFwyxf+9rXtGXLFnV1damlpSXs4sDiJz/5iT772c9qzpw5mb9NTU0pkUiooqJCqVRqxmNhIBDx0f79+zU2Npb5fWhoSNdff72eeeYZLV++XE1NTSGWDmYHDhzQRz/6US1btkz/9E//FPoHs9wtX75c11xzjR577DFJp5r+zz//fH3ta1/TAw88EHLpIJ3qer7zzjv14x//WC+99JJaW1vDLhJsjI+Pa9++fTP+dvvtt+vSSy/V/fffH4muNHJEfHT++efP+P3ss8+WJF188cUEIRFy4MABrVy5UhdccIE2bNigw4cPZx4777zzQixZ+brnnnt066236uqrr9Y111yjRx99VEePHtXtt98edtFw2po1a/TDH/5QW7ZsUU1Njd555x1JUl1dnebNmxdy6WCoqamZFWycddZZmj9/fiSCEIlABNCLL76ovXv3au/evbMCRBoMw/HFL35Rhw8f1oMPPqh33nlHV1xxhV544YVZCawIz3e+8x1J0sqVK2f8/fvf/75uu+224AuE2KJrBgAAhIZsPAAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEBoCEQAAEJr/H/0pGdbn0WM/AAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -293,31 +297,38 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:20<00:00, 24.27it/s]\n"
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:00<00:00, 897.20it/s]"
      ]
     },
     {
      "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"
+      "INFO:QMCTorch|   Acceptance rate     : 3.60 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 895.57 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 0.56 sec.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\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>]"
+       "[<matplotlib.lines.Line2D at 0x7fa8826878e0>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687c40>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687e20>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687460>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687f70>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687cd0>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687d60>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa882687520>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa8827d96a0>,\n",
+       " <matplotlib.lines.Line2D at 0x7fa8827d9fa0>]"
       ]
      },
      "execution_count": 8,
@@ -326,7 +337,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -362,7 +373,7 @@
       "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| Object name changed to Solver_2\n",
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| QMC Solver \n",
@@ -400,23 +411,25 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:53<00:00,  4.40it/s]\n"
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:00<00:00, 535.45it/s]"
      ]
     },
     {
      "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"
+      "INFO:QMCTorch|   Acceptance rate     : 2.64 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 534.84 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 0.93 sec.\n",
+      "INFO:QMCTorch|  Energy   : -76.697502 +/- 4.330277\n",
+      "INFO:QMCTorch|  Variance : 1875.130127\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
      ]
     }
    ],
@@ -460,16 +473,16 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:32<00:00,  5.42it/s]\n"
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 205.41it/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|   Acceptance rate     : 2.50 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 205.32 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 2.44 sec.\n",
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch|  Sampling trajectory\n"
      ]
@@ -478,23 +491,12 @@
      "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"
+      "INFO:QMCTorch|  Energy  : 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:01<00:00, 56.11it/s]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -512,7 +514,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -527,9 +529,8 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.0"
-  },
-  "orig_nbformat": 4
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
index b262973e..214b5a9c 100644
--- a/docs/notebooks/wfopt.ipynb
+++ b/docs/notebooks/wfopt.ipynb
@@ -33,7 +33,7 @@
     "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",
+    "from qmctorch.utils.plot_data import plot_energy\n",
     "set_torch_double_precision()"
    ]
   },
@@ -87,7 +87,7 @@
       "INFO:QMCTorch|\n",
       "INFO:QMCTorch| Wave Function\n",
       "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Jastrow kernel      : ee -> PadeJastrowKernel\n",
       "INFO:QMCTorch|  Highest MO included : 10\n",
       "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
       "INFO:QMCTorch|  Number of confs     : 4\n",
@@ -112,7 +112,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -150,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -186,18 +186,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "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",
@@ -214,14 +209,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Comfiguring the solver\n",
+    "## Configuring 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,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -238,7 +233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -254,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -262,15 +257,16 @@
    ]
   },
   {
+   "attachments": {},
    "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"
+    "The gradients of the wave function w.r.t. the variational parameters can be computed directly via automatic differntiation (`grad='auto'`) or manually (`grad='manual'`) via a reduced noise formula. We pick here a manual calculation"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -287,7 +283,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,7 +304,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -331,266 +327,255 @@
       "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"
+      "INFO:QMCTorch|  epoch 0 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155820 +/- 0.003248\n",
+      "INFO:QMCTorch|  variance : 0.229678\n",
+      "INFO:QMCTorch|  epoch done in 0.17 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 1 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.154966 +/- 0.003175\n",
+      "INFO:QMCTorch|  variance : 0.224524\n",
+      "INFO:QMCTorch|  epoch done in 0.23 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 2 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.153755 +/- 0.003123\n",
+      "INFO:QMCTorch|  variance : 0.220823\n",
+      "INFO:QMCTorch|  epoch done in 0.25 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 3 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.152865 +/- 0.003169\n",
+      "INFO:QMCTorch|  variance : 0.224055\n",
+      "INFO:QMCTorch|  epoch done in 0.22 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 4 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155440 +/- 0.003123\n",
+      "INFO:QMCTorch|  variance : 0.220856\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 5 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.152281 +/- 0.003132\n",
+      "INFO:QMCTorch|  variance : 0.221490\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 6 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155656 +/- 0.003057\n",
+      "INFO:QMCTorch|  variance : 0.216128\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 7 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155033 +/- 0.003072\n",
+      "INFO:QMCTorch|  variance : 0.217255\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 8 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156729 +/- 0.003055\n",
+      "INFO:QMCTorch|  variance : 0.216035\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 9 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157059 +/- 0.003023\n",
+      "INFO:QMCTorch|  variance : 0.213726\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 10 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155099 +/- 0.003046\n",
+      "INFO:QMCTorch|  variance : 0.215355\n",
+      "INFO:QMCTorch|  epoch done in 0.46 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 11 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157807 +/- 0.002978\n",
+      "INFO:QMCTorch|  variance : 0.210545\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 12 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155917 +/- 0.002920\n",
+      "INFO:QMCTorch|  variance : 0.206467\n",
+      "INFO:QMCTorch|  epoch done in 0.25 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 13 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.160233 +/- 0.002908\n",
+      "INFO:QMCTorch|  variance : 0.205608\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 14 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155051 +/- 0.003021\n",
+      "INFO:QMCTorch|  variance : 0.213640\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 15 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157552 +/- 0.002922\n",
+      "INFO:QMCTorch|  variance : 0.206606\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 16 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.150777 +/- 0.002986\n",
+      "INFO:QMCTorch|  variance : 0.211157\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 17 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.153752 +/- 0.002926\n",
+      "INFO:QMCTorch|  variance : 0.206869\n",
+      "INFO:QMCTorch|  epoch done in 0.18 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 18 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.154157 +/- 0.002893\n",
+      "INFO:QMCTorch|  variance : 0.204567\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 19 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156157 +/- 0.002824\n",
+      "INFO:QMCTorch|  variance : 0.199705\n",
+      "INFO:QMCTorch|  epoch done in 0.43 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 20 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161703 +/- 0.002866\n",
+      "INFO:QMCTorch|  variance : 0.202681\n",
+      "INFO:QMCTorch|  epoch done in 0.22 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 21 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156807 +/- 0.002791\n",
+      "INFO:QMCTorch|  variance : 0.197351\n",
+      "INFO:QMCTorch|  epoch done in 0.22 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 22 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156593 +/- 0.002774\n",
+      "INFO:QMCTorch|  variance : 0.196173\n",
+      "INFO:QMCTorch|  epoch done in 0.18 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 23 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.155829 +/- 0.002814\n",
+      "INFO:QMCTorch|  variance : 0.199004\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 24 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.158552 +/- 0.002720\n",
+      "INFO:QMCTorch|  variance : 0.192327\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 25 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157268 +/- 0.002651\n",
+      "INFO:QMCTorch|  variance : 0.187444\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 26 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.160739 +/- 0.002627\n",
+      "INFO:QMCTorch|  variance : 0.185774\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 27 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.156840 +/- 0.002650\n",
+      "INFO:QMCTorch|  variance : 0.187409\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 28 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.160052 +/- 0.002668\n",
+      "INFO:QMCTorch|  variance : 0.188656\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 29 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161738 +/- 0.002561\n",
+      "INFO:QMCTorch|  variance : 0.181082\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 30 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.163425 +/- 0.002620\n",
+      "INFO:QMCTorch|  variance : 0.185234\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 31 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.167101 +/- 0.002546\n",
+      "INFO:QMCTorch|  variance : 0.180017\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 32 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157386 +/- 0.002624\n",
+      "INFO:QMCTorch|  variance : 0.185573\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 33 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.163439 +/- 0.002552\n",
+      "INFO:QMCTorch|  variance : 0.180488\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 34 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161475 +/- 0.002532\n",
+      "INFO:QMCTorch|  variance : 0.179012\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 35 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.162207 +/- 0.002483\n",
+      "INFO:QMCTorch|  variance : 0.175559\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 36 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.160581 +/- 0.002549\n",
+      "INFO:QMCTorch|  variance : 0.180231\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 37 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.160479 +/- 0.002471\n",
+      "INFO:QMCTorch|  variance : 0.174733\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 38 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.162336 +/- 0.002502\n",
+      "INFO:QMCTorch|  variance : 0.176936\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 39 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.163931 +/- 0.002522\n",
+      "INFO:QMCTorch|  variance : 0.178305\n",
+      "INFO:QMCTorch|  epoch done in 0.19 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 40 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.162977 +/- 0.002429\n",
+      "INFO:QMCTorch|  variance : 0.171763\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 41 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.162803 +/- 0.002436\n",
+      "INFO:QMCTorch|  variance : 0.172285\n",
+      "INFO:QMCTorch|  epoch done in 0.18 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 42 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.162275 +/- 0.002436\n",
+      "INFO:QMCTorch|  variance : 0.172260\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 43 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161893 +/- 0.002421\n",
+      "INFO:QMCTorch|  variance : 0.171202\n",
+      "INFO:QMCTorch|  epoch done in 0.21 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 44 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161169 +/- 0.002388\n",
+      "INFO:QMCTorch|  variance : 0.168865\n",
+      "INFO:QMCTorch|  epoch done in 0.18 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 45 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.163101 +/- 0.002353\n",
+      "INFO:QMCTorch|  variance : 0.166373\n",
+      "INFO:QMCTorch|  epoch done in 1.37 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 46 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.161588 +/- 0.002367\n",
+      "INFO:QMCTorch|  variance : 0.167382\n",
+      "INFO:QMCTorch|  epoch done in 0.18 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 47 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.164853 +/- 0.002345\n",
+      "INFO:QMCTorch|  variance : 0.165804\n",
+      "INFO:QMCTorch|  epoch done in 0.22 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 48 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.167272 +/- 0.002287\n",
+      "INFO:QMCTorch|  variance : 0.161681\n",
+      "INFO:QMCTorch|  epoch done in 0.20 sec.\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 49 | 5000 sampling points\n",
+      "INFO:QMCTorch|  energy   : -1.157956 +/- 0.002319\n",
+      "INFO:QMCTorch|  variance : 0.164008\n",
+      "INFO:QMCTorch|  epoch done in 0.22 sec.\n"
      ]
     }
    ],
@@ -600,12 +585,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -646,5 +631,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/rst/qmctorch.rst b/docs/rst/qmctorch.rst
index 1f81fa67..80c7d8b3 100644
--- a/docs/rst/qmctorch.rst
+++ b/docs/rst/qmctorch.rst
@@ -1,4 +1,4 @@
-Wave Function ansatz in QMCTorch
+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
@@ -15,22 +15,28 @@ These atomic orbital values are then transformed to molecular orbital values thr
 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. 
+The main wave function in QMCTorch is implemented in the ``SlaterJastrow`` class. The definition of the class is as follows :
 
-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:
+.. code-block:: python
+
+    class SlaterJastrow(WaveFunction):
+        def __init__(
+            self,
+            mol,
+            jastrow='default',
+            backflow=None,
+            configs="ground_state",
+            kinetic="jacobi",
+            cuda=False,
+            include_all_mo=True,
+        ):
 
-* ``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
+Different functional form can be created from this class depending on the need of the user. We review here a few of these forms. 
 
 
-Slater Jastrow Wave Function
-----------------------------------------
+Simple 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:
@@ -62,7 +68,15 @@ The determinantal parts in the expression of :math:`\Psi` are given by the spin-
 
 A ``SlaterJastrow`` wave function can instantiated following :
 
->>> wf = SlaterJastrow(mol, configs='single_double(2,2)', jastrow_kernel=PadeJastrowKernel)
+.. code-block:: python 
+
+   from qmctorch.scf import Molecule
+   from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+   from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+   from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+   mol = Molecule('H 0 0 0; H 0 0 1')
+   jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+   wf = SlaterJastrow(mol, configs='single_double(2,2)', jastrow=jastrow)
 
 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 :
@@ -72,135 +86,162 @@ are specified with the ``configs`` arguments which can take the following values
   * ``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.
+Finally the Jastrow factor can be specifed using the ``jastrow``. We used here a Pade-Jastrow kernel that is already implemented in QMCTorch
 
-The wave function is then constructed as :
-
-.. math::
+Custom Jastrow factor
+^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    \Psi(R) = J(R) \sum_n c_n D_n^{\uparrow}(Q) D_n^{\downarrow}(Q)
+It is possible to define custom Jastrow factor and use these forms in the definition of the wave function. 
 
-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:
+.. code-block:: python 
 
->>> 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)
+    from torch import nn 
+    from qmctorch.wavefunction import SlaterJastrow
+    from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+    from qmctorch.wavefunction.jastrows.elec_elec.kernels import JastrowKernelElectronElectronBase
 
-Compared to the ``SlaterJastrow`` wave function, the kernel of the backflow transformation must be specified. By default the inverse kernel will be used.
+    class MyJastrowKernel(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)
 
-Orbital Dependent Backflow Transformation
-******************************************
+    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)
 
-The backflow transformation can be different for each atomic orbitals.
+    jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel, kernel_kwargs={'size': 64})
 
-.. math::
+    wf = SlaterJastrow(mol, jastrow=jastrow)
 
-    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.
+Combining Several Jastrow Factors
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This wave function can be used with
+As shown on the figure above it is possible to combine several Jastrow factors to account for not only the electron-electron correlations but also electron-nuclei and three body terms. 
+This can easily be done by passing a list of Jastrow factors to the `SlaterJastrow` wave function. 
+For example if we want to combine a fully connected  electron-electron neural Jastrow factor with a fully connected electron-nuclei neural Jastrow, we can simply use:
 
->>> 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)
+.. code-block:: python 
 
+    import torch
+    from qmctorch.scf import Molecule
+    from qmctorch.wavefunction import SlaterJastrow
 
-Many-Body Jastrow factors
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    from qmctorch.wavefunction.jastrows.elec_elec import (
+        JastrowFactor as JastrowFactorElecElec,
+        FullyConnectedJastrowKernel as FCEE,
+    )
+    from qmctorch.wavefunction.jastrows.elec_nuclei import (
+        JastrowFactor as JastrowFactorElecNuclei,
+        FullyConnectedJastrowKernel as FCEN,
+    )
 
-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. 
+    mol = Molecule(
+            atom="Li 0 0 0; H 0 0 3.14", 
+            unit='bohr', 
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True)
 
-* ``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
+    jastrow_ee = JastrowFactorElecElec(mol, FCEE)
 
+    jastrow_en = JastrowFactorElecNuclei(mol, FCEN)
 
+    wf = SlaterJastrow(mol, jastrow=[jastrow_ee, jastrow_en])
 
-Many-Body Jastrow Wave Function
-----------------------------------------
+Wave Functions with Backflow Transformations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The Jastrow factor combines here multiple terms that represent electron-electron, electron-nuclei and electron-electron-nuclei terms. 
+As seen on the figure above, a backflow transformation of the electronic positions can be added to the definition of the wave function. 
+Following this transformation, each electron becomes a quasi-particle whose position depends on all
+electronic positions. The backflow transformation is given by :
 
 .. 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)
+    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 :
 
->>> 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})
+.. 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 :
 
-Many-Body Jastrow Wave Function with backflow transformation 
-------------------------------------------------------------------
+.. math::
 
-A backflow transformation can be used together with the many body Jastrow
+    \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 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)
+.. code-block:: python 
+
+    from qmctorch.scf import Molecule
+    from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+
+    from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+    from qmctorch.wavefunction.orbitals.backflow import (
+        BackFlowTransformation,
+        BackFlowKernelInverse,
+    )
+
+    # molecule
+    mol = Molecule(
+        atom="Li 0 0 0; H 0 0 3.015",
+        unit="bohr",
+        calculator="pyscf",
+        basis="sto-3g",
+        redo_scf=True,
+    )
+
+    # define jastrow factor
+    jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+    # define backflow trans
+    backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+
+    # define the wave function
+    wf = SlaterJastrow(
+        mol,
+        configs="single_double(2,2)",
+        jastrow=jastrow,
+        backflow=backflow,
+    )
+
+Custom Backflow Transformation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As for the Jastrow factor, it is possible to create custom backlfow transformations and use them in the definition of the wave function. 
+For example to define a fully connected backflow kernel and use it we can use:
+
+.. code-block:: python 
+
+    import torch
+    from torch import nn 
+    from qmctorch.scf import Molecule
+    from qmctorch.wavefunction import SlaterJastrow
+    from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
+    from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation
+
+    class MyBackflowKernel(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)
+
+    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)
+    backflow = BackFlowTransformation(mol, MyBackflowKernel, backflow_kernel_kwargs={'size': 8})
+    wf = SlaterJastrow(mol, backflow=backflow)
\ No newline at end of file
diff --git a/docs/source/modules.rst b/docs/source/modules.rst
index 762c26c8..31572603 100644
--- a/docs/source/modules.rst
+++ b/docs/source/modules.rst
@@ -1,9 +1,10 @@
 
-Subpackages
------------
+Python Interface
+-------------------
 
 .. toctree::
-   :maxdepth: 4
+   :maxdepth: 1
+   :hidden:
 
    qmctorch.sampler
    qmctorch.scf
@@ -11,7 +12,7 @@ Subpackages
    qmctorch.utils
    qmctorch.wavefunction
 
-Module contents
+Reference
 ---------------
 
 .. automodule:: qmctorch
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
new file mode 100644
index 00000000..5c572f82
--- /dev/null
+++ b/h5x/baseimport.py
@@ -0,0 +1,9 @@
+from qmctorch.utils.plot_data import ( # pylint: disable=unused-import
+    plot_energy, plot_data, plot_block, plot_walkers_traj)
+import matplotlib.pyplot as plt # pylint: disable=unused-import
+import numpy as np # pylint: disable=unused-import
+
+print(r"  ____    __  ______________             _")
+print(r" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
+print(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
+print(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
diff --git a/notebooks/NeuralJastrow.ipynb b/notebooks/NeuralJastrow.ipynb
new file mode 100644
index 00000000..edb840e8
--- /dev/null
+++ b/notebooks/NeuralJastrow.ipynb
@@ -0,0 +1,384 @@
+{
+ "cells": [
+  {
+   "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 qmctorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#  Jastrow Factor\n",
+    "\n",
+    "The wave function of the molecular system is written as :\n",
+    "\n",
+    "$$\n",
+    "\\Psi(R) = J(R) \\sum_n c_n \\det(A_\\uparrow(r_\\uparrow)) \\det(A_\\downarrow(r_\\downarrow))\n",
+    "$$\n",
+    "\n",
+    "where $J(R)$ is the so called Jastrow factor, and $A_\\uparrow$($A_\\downarrow$) is the matrix of the molecular orbitals values for the spin up(down) electron\n",
+    "\n",
+    "The Jastrow factor is written as the exponential of a kernel function :\n",
+    "\n",
+    "$$\n",
+    "J(R) = \\exp\\left( \\sum_{i<j}  f(r_{ij}) \\right) \n",
+    "$$\n",
+    "\n",
+    "where $r_{ij}$ denotes the distance between electrons $i$ and $j$. The kernel function $f(r_{ij})$ can take differet forms. Traditionally it is written as a Pade-Jastrow function\n",
+    "\n",
+    "$$\n",
+    "f(r_{ij}) = \\frac{a r_{ij}}{1+ \\omega r_{ij}}\n",
+    "$$\n",
+    "\n",
+    "where $a$ is a fixed weight and $\\omega$ a variational parameter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The electron-electron Jastrow factor class (`JastrowFactorElectronElectron`) orchestrates the calculations of the Jastrow factors (and its 1st and 2nd derivatives). It can take different kernel functions as for example the `PadeJastrowKernel`. The example below shows how to use this class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel\n",
+    "\n",
+    "# number of spin up/down electrons\n",
+    "nup, ndown = 2, 2\n",
+    "nelec = nup + ndown\n",
+    "\n",
+    "# define the jastrow factor\n",
+    "jastrow = JastrowFactorElectronElectron(\n",
+    "            nup, ndown,\n",
+    "            PadeJastrowKernel,\n",
+    "            kernel_kwargs={'w': 0.1})\n",
+    "\n",
+    "# define random electronic positions\n",
+    "nbatch = 10\n",
+    "pos = torch.rand(nbatch, nelec * 3)\n",
+    "\n",
+    "# compute the jastrow\n",
+    "jval = jastrow(pos)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Neural Jastrows\n",
+    "\n",
+    "The functional form $f(r_{ij}) = ar_{ij}(1+\\omega r_{ij})^{-1}$ only offers one single variational parameter and does not offer a lot of flexibility. It is however possible to replace that form by a simple fully connected neural network\n",
+    "\n",
+    "This network takes a single input value ($r_{ij}$) and outputs a single value, i.e. the value of the kernel. A simple 2 layer fully connected neurakl network  Jastrow Kernel has been implemented in the `FullyConnectedJastrowKernel` class that can be used in the `JastrowFactorElectronElectron` as follow:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel\n",
+    "\n",
+    "# number of spin up/down electrons\n",
+    "nup, ndown = 2, 2\n",
+    "nelec = nup + ndown\n",
+    "\n",
+    "# define the jastrow factor\n",
+    "jastrow = JastrowFactorElectronElectron(\n",
+    "            nup, ndown,\n",
+    "            FullyConnectedJastrowKernel,\n",
+    "            kernel_kwargs={'size1': 32, 'size2': 64})\n",
+    "\n",
+    "# define random electronic positions\n",
+    "nbatch = 10\n",
+    "pos = torch.rand(nbatch, nelec * 3)\n",
+    "\n",
+    "# compute the jastrow\n",
+    "jval = jastrow(pos)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SlaterJastrow Wave function\n",
+    "\n",
+    "Both Jastrow factors can be used to define a `SlaterJastrow` wavefunction. The example below shows how to do that for a `LiH` molecule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "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 = -7.85928101642665\n",
+      "INFO:QMCTorch|  Molecule name       : HLi\n",
+      "INFO:QMCTorch|  Number of electrons : 4\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 6\n",
+      "INFO:QMCTorch|  Number of MOs       : 6\n",
+      "INFO:QMCTorch|  SCF Energy          : -7.859 Hartree\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 : 6\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   : 65\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel, FullyConnectedJastrowKernel\n",
+    "\n",
+    "# define the molecule\n",
+    "mol = Molecule(\n",
+    "            atom='Li 0 0 0; H 0 0 3.14',\n",
+    "            unit='bohr',\n",
+    "            calculator='pyscf',\n",
+    "            basis='sto-3g')\n",
+    "\n",
+    "# define the Slater Jastrow wavefunction\n",
+    "wf = SlaterJastrow(mol,\n",
+    "                   jastrow_kernel=PadeJastrowKernel,\n",
+    "                   jastrow_kernel_kwargs={'w': 0.1},\n",
+    "                   configs='single_double(2,2)')\n",
+    "\n",
+    "# define random electronic positions\n",
+    "nbatch = 10\n",
+    "pos = torch.rand(nbatch, nelec * 3)\n",
+    "\n",
+    "# compute the value of the wave function\n",
+    "wfval = wf(pos)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Reusing scf results from HLi_pyscf_sto-3g.hdf5\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : FullyConnectedJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 6\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   : 2210\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel, FullyConnectedJastrowKernel\n",
+    "\n",
+    "# define the molecule\n",
+    "mol = Molecule(\n",
+    "            atom='Li 0 0 0; H 0 0 3.014',\n",
+    "            unit='bohr',\n",
+    "            calculator='pyscf',\n",
+    "            basis='sto-3g')\n",
+    "\n",
+    "# define the Slater Jastrow wavefunction\n",
+    "wf = SlaterJastrow(mol,\n",
+    "                   jastrow_kernel=FullyConnectedJastrowKernel,\n",
+    "                   jastrow_kernel_kwargs={'size1': 32, 'size2': 64},\n",
+    "                   configs='single_double(2,2)')\n",
+    "\n",
+    "# define random electronic positions\n",
+    "nbatch = 10\n",
+    "pos = torch.rand(nbatch, nelec * 3)\n",
+    "\n",
+    "# compute the value of the wave function\n",
+    "wfval = wf(pos)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TODO : Exploring different network architetures\n",
+    "\n",
+    "It would be interesting to see how the accuracy of the total energy varies for different network architecture (i.e. different number of layers, different layer size, different activation function etc ...). We should compared the performance of both PadeJastrow and FullyConnectedJastrow for a few different molecules. Some mmolecule candidates can be found in https://arxiv.org/pdf/1909.02487.pdf together with their optimum energies.  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel, FullyConnectedJastrowKernel\n",
+    "\n",
+    "# We should use ADF as calculator so this cell requires a valid ADF license\n",
+    "\n",
+    "if 0:\n",
+    "    # H2 : Expected exact total energy : -1.169\n",
+    "    mol = Molecule(atom='H 0 0 -0.69; H 0. 0. 0.69', calculator='adf', basis='dzp', unit='bohr')\n",
+    "\n",
+    "    # LiH : Expected exact total energy : -8.0705\n",
+    "    # mol = Molecule(atom='Li 0.0 0.0 0.0; H 0. 0. 3.015', calculator='adf', basis='dzp', unit='bohr')\n",
+    "\n",
+    "    # Li2 : Expected exact total energy : -14.9954\n",
+    "    # mol = Molecule(atom='Li 0.0 0.0 0.0; Li 0. 0. 5.051', calculator='adf', basis='dzp', unit='bohr')\n",
+    "\n",
+    "    # N2 : Expected exact total energy : -109.5423\n",
+    "    # mol = Molecule(atom='N 0.0 0.0 0.0; N 0. 0. 2.068', calculator='adf', basis='dzp', unit='bohr')\n",
+    "\n",
+    "    # wavefunction\n",
+    "    wf = SlaterJastrow(mol,\n",
+    "                       jastrow_kernel=FullyConnectedJastrowKernel,\n",
+    "                       jastrow_kernel_kwargs={'size1': 32, 'size2': 64},\n",
+    "                       configs='single_double(4,12)')\n",
+    "\n",
+    "    # sampler\n",
+    "    sampler = Metropolis(nwalkers=10000,\n",
+    "                         nstep=2000, step_size=0.05,\n",
+    "                         ntherm=-1, ndecor=100,\n",
+    "                         nelec=wf.nelec, init=mol.domain('atomic'),\n",
+    "                         move={'type': 'all-elec', 'proba': 'normal'},\n",
+    "                         cuda=cuda)\n",
+    "\n",
+    "    # optimizer\n",
+    "    lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},\n",
+    "               {'params': wf.ao.parameters(), 'lr': 1E-2},\n",
+    "               {'params': wf.mo.parameters(), 'lr': 1E-2},\n",
+    "               {'params': wf.fc.parameters(), 'lr': 1E-2}]\n",
+    "    opt = optim.Adam(lr_dict, lr=1E-3)\n",
+    "\n",
+    "    # scheduler\n",
+    "    scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)\n",
+    "\n",
+    "    # solver\n",
+    "    solver = Solver(wf=wf, sampler=sampler,\n",
+    "                                 optimizer=opt, scheduler=scheduler)\n",
+    "\n",
+    "    # optimize the wave function\n",
+    "    solver.track_observable(['local_energy', 'parameters'])\n",
+    "\n",
+    "    solver.configure_resampling(mode='update',\n",
+    "                                resample_every=1,\n",
+    "                                nstep_update=100)\n",
+    "    solver.ortho_mo = False\n",
+    "\n",
+    "    obs = solver.run(500, batchsize=200)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Preliminary results have show that the fully connected network does not yields much better results. \n",
+    "\n",
+    "![Fully connected VS Pade Jastrow](./fcjastrow.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Bonus Electron-Electron cusp conditions\n",
+    "\n",
+    "In the simple Pade-Jastrow function the value of the $a$ parameter is given by the so-called electron-electron cusp conditions. These conditions are here to insured that the value of the total energy remains finite at the coalescence point, i.e. when two electrons have the same positions. \n",
+    "\n",
+    "It can be shown that this is respected when\n",
+    "\n",
+    "$$\n",
+    "\\frac{1}{J(R)}{\\frac{\\partial J(R)}{\\partial r_{ij}} |_{r_{ij}=0}} = \\frac{1}{4} \n",
+    "$$\n",
+    "\n",
+    "for same-spin electrons and \n",
+    "\n",
+    "$$\n",
+    "\\frac{1}{J(R)}{\\frac{\\partial J(R)}{\\partial r_{ij}} |_{r_{ij}=0}} = \\frac{1}{2} \n",
+    "$$\n",
+    "\n",
+    "for opposite spin electrons.\n",
+    "\n",
+    "For the Pade-Jastrow function this translates into $a=1/4$ ($a=1/2$) for same(opposite) spin electrons. However realizing the same condition for the fully connected Jastrow factor is still to be clarified. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "qmctorch"
+  },
+  "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": 4
+}
diff --git a/notebooks/fcjastrow.png b/notebooks/fcjastrow.png
new file mode 100755
index 00000000..ae407e01
Binary files /dev/null and b/notebooks/fcjastrow.png differ
diff --git a/docs/example/colab/google_collab.ipynb b/notebooks/google_collab.ipynb
similarity index 100%
rename from docs/example/colab/google_collab.ipynb
rename to notebooks/google_collab.ipynb
diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
new file mode 100644
index 00000000..47f98cd7
--- /dev/null
+++ b/notebooks/test.ipynb
@@ -0,0 +1,439 @@
+{
+ "metadata": {
+  "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,
+  "kernelspec": {
+   "name": "python3",
+   "display_name": "Python 3.8.0 64-bit ('qmctorch': conda)"
+  },
+  "interpreter": {
+   "hash": "7ce898621bfdc1ef835a37ba44cfccabe14bea8b663e0a8a268cd00c3f89209b"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing LiH_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -7.86200927212022\n",
+      "INFO:QMCTorch|  Molecule name       : LiH\n",
+      "INFO:QMCTorch|  Number of electrons : 4\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 6\n",
+      "INFO:QMCTorch|  Number of MOs       : 6\n",
+      "INFO:QMCTorch|  SCF Energy          : -7.862 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.scf import Molecule\n",
+    "mol = Molecule(\n",
+    "    atom='Li 0 0 0; H 0 0 3.015',\n",
+    "    unit='bohr',\n",
+    "    calculator='pyscf',\n",
+    "    basis='sto-3g',\n",
+    "    redo_scf=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "Using backend: pytorch\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals\n",
+    "from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow\n",
+    "from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation\n",
+    "from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse\n",
+    "\n",
+    "\n",
+    "ao = AtomicOrbitals(mol)\n",
+    "\n",
+    "bf = BackFlowTransformation(mol, BackFlowKernelInverse)\n",
+    "aobf = AtomicOrbitalsBackFlow(mol, bf)"
+   ]
+  },
+  {
+   "source": [
+    "import torch\n",
+    "pos = torch.rand(11,12)\n",
+    "a,b,c = ao(pos,[0,1,2])\n",
+    "print(b.shape)\n",
+    "print(aobf(pos,1,sum_grad=True).shape)"
+   ],
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": 23,
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "torch.Size([11, 4, 6, 3])\ntorch.Size([4, 11, 4, 6])\n"
+     ]
+    }
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "INFO:QMCTorch|\nINFO:QMCTorch| Wave Function\nINFO:QMCTorch|  Jastrow factor      : True\nINFO:QMCTorch|  Jastrow kernel      : ee -> PadeJastrowKernel\nINFO:QMCTorch|  Highest MO included : 6\nINFO:QMCTorch|  Configurations      : single_double(2,2)\nINFO:QMCTorch|  Number of confs     : 4\nINFO:QMCTorch|  Kinetic energy      : jacobi\nINFO:QMCTorch|  Number var  param   : 66\nINFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.wavefunction.slater_jastrow import  SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel\n",
+    "\n",
+    "jastrow = JastrowFactorElectronElectron(\n",
+    "            mol, PadeJastrowKernel)\n",
+    "\n",
+    "wf = SlaterJastrow(mol,\n",
+    "                                kinetic='jacobi',\n",
+    "                                include_all_mo=True,\n",
+    "                                configs='single_double(2,2)',\n",
+    "                                jastrow=jastrow,\n",
+    "                                backflow=bf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "2 torch.Size([4, 11, 4, 6])\n"
+     ]
+    },
+    {
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "tensor([[[[-3.4585e+00,  8.2400e-01,  5.9673e-01,  5.2664e-02,  2.4160e-01,\n",
+       "           -3.0029e-01],\n",
+       "          [ 1.1267e-04, -6.3371e-06, -4.4738e-05, -9.9755e-05, -1.3011e-04,\n",
+       "           -5.8372e-06],\n",
+       "          [ 4.8743e-04, -1.6771e-04, -3.6755e-05,  2.5133e-04, -2.0177e-04,\n",
+       "            8.4395e-05],\n",
+       "          [ 5.0144e-03, -1.2489e-03, -8.4502e-04, -1.0444e-04, -5.4762e-04,\n",
+       "            4.2804e-04]],\n",
+       "\n",
+       "         [[-8.4607e-01,  2.5296e-01,  1.0549e-01,  1.0515e-01,  1.3094e-01,\n",
+       "           -1.1920e-01],\n",
+       "          [ 2.9163e-04, -1.2779e-04,  8.0072e-06,  1.2990e-04,  1.4239e-05,\n",
+       "            7.4367e-05],\n",
+       "          [ 3.8593e-04, -2.8265e-05, -1.4598e-04, -7.4126e-05, -2.0316e-04,\n",
+       "           -1.2602e-05],\n",
+       "          [ 3.8184e-03, -8.7080e-04, -7.9407e-04,  8.6443e-05, -4.0696e-04,\n",
+       "            2.7453e-04]],\n",
+       "\n",
+       "         [[-2.4019e+00,  6.0408e-01,  3.8411e-01,  4.4494e-02,  2.2038e-01,\n",
+       "           -2.4374e-01],\n",
+       "          [ 1.4596e-04, -1.6357e-06, -6.4564e-05, -1.3561e-04, -5.4061e-05,\n",
+       "           -1.0255e-05],\n",
+       "          [ 2.9931e-04, -2.2392e-04,  1.2471e-04, -2.6555e-04, -3.2219e-05,\n",
+       "            1.7634e-04],\n",
+       "          [ 4.3139e-06, -2.4053e-05,  2.4329e-05, -7.3137e-05,  1.4307e-05,\n",
+       "            1.8021e-05]],\n",
+       "\n",
+       "         ...,\n",
+       "\n",
+       "         [[-1.4150e+00,  3.8191e-01,  2.1274e-01, -1.7488e-02,  1.8288e-01,\n",
+       "           -1.6232e-01],\n",
+       "          [ 1.8851e-04,  3.3737e-05, -1.1100e-04,  1.4311e-05, -1.7988e-04,\n",
+       "           -1.8796e-05],\n",
+       "          [ 2.9377e-04, -9.7015e-05, -3.3703e-05, -1.4951e-04, -4.8564e-05,\n",
+       "            3.8449e-05],\n",
+       "          [ 2.3485e-03, -5.7343e-04, -4.4120e-04, -2.3402e-04, -2.1868e-04,\n",
+       "            1.9037e-04]],\n",
+       "\n",
+       "         [[-5.4499e-01,  1.5576e-01,  9.4968e-02, -6.1359e-02,  1.2517e-01,\n",
+       "           -4.1250e-02],\n",
+       "          [ 3.3965e-04, -1.0536e-04, -4.7166e-05, -1.0127e-04, -3.2158e-05,\n",
+       "            3.6774e-05],\n",
+       "          [ 2.4309e-03, -5.6311e-04, -4.6736e-04,  1.8210e-04, -3.9161e-04,\n",
+       "            1.8625e-04],\n",
+       "          [ 2.9680e-04, -1.2709e-04,  1.2213e-05, -2.0706e-05,  1.1811e-05,\n",
+       "            8.5823e-05]],\n",
+       "\n",
+       "         [[-4.1738e-01,  1.0293e-01,  1.0736e-01, -4.9801e-03,  7.9325e-02,\n",
+       "            1.7579e-02],\n",
+       "          [ 9.7024e-04, -2.1349e-04, -2.1595e-04, -5.1742e-06, -1.5848e-04,\n",
+       "            6.5324e-05],\n",
+       "          [ 1.5017e-03, -3.1993e-04, -3.1753e-04,  1.5841e-05, -1.6972e-04,\n",
+       "            9.4849e-05],\n",
+       "          [ 1.2239e-03, -2.1466e-04, -3.2525e-04, -1.7351e-04, -1.9602e-04,\n",
+       "            3.8534e-05]]],\n",
+       "\n",
+       "\n",
+       "        [[[ 2.8810e-03, -6.1109e-04, -5.8798e-04, -1.2937e-04, -2.1166e-04,\n",
+       "            1.7518e-04],\n",
+       "          [-3.5660e-01,  1.0442e-01,  8.0572e-02,  8.6818e-02,  1.0072e-01,\n",
+       "            1.6393e-02],\n",
+       "          [ 1.0771e-03, -2.7363e-04, -1.9062e-04, -3.0244e-06, -1.1162e-04,\n",
+       "            1.0533e-04],\n",
+       "          [ 1.0053e-03, -2.2365e-04, -1.9819e-04, -2.2618e-04, -1.7132e-04,\n",
+       "            6.6187e-05]],\n",
+       "\n",
+       "         [[ 1.0457e-03, -3.1038e-04, -1.3297e-04,  7.7343e-05, -3.2090e-05,\n",
+       "            1.4534e-04],\n",
+       "          [-4.1871e-01,  1.3104e-01,  4.6591e-02,  2.0882e-02, -1.1528e-02,\n",
+       "           -6.5046e-02],\n",
+       "          [ 5.2559e-04, -1.5998e-04, -1.0082e-04, -8.5157e-05, -6.6910e-05,\n",
+       "            6.1184e-06],\n",
+       "          [ 1.4452e-03, -4.7197e-04, -1.4555e-04,  6.2803e-05, -2.0713e-06,\n",
+       "            2.1169e-04]],\n",
+       "\n",
+       "         [[ 1.4363e-03, -2.8255e-04, -3.2544e-04, -1.7898e-04, -9.6812e-05,\n",
+       "            6.5888e-05],\n",
+       "          [-6.3176e-01,  1.7018e-01,  1.1356e-01,  5.3252e-02,  3.3374e-02,\n",
+       "           -5.5724e-02],\n",
+       "          [ 1.6397e-03, -3.4117e-04, -3.7556e-04, -1.1623e-04, -1.7386e-04,\n",
+       "            1.0528e-04],\n",
+       "          [ 8.8348e-04, -3.8637e-04,  2.3481e-05, -2.8742e-05,  1.0385e-04,\n",
+       "            2.1798e-04]],\n",
+       "\n",
+       "         ...,\n",
+       "\n",
+       "         [[ 1.2135e-03, -2.1477e-04, -3.1362e-04,  2.0650e-05, -2.5341e-04,\n",
+       "            3.6838e-05],\n",
+       "          [-4.0839e-01,  1.0659e-01,  9.0275e-02, -5.4226e-02,  8.5573e-02,\n",
+       "           -4.3051e-03],\n",
+       "          [ 4.6819e-04, -1.3138e-04, -7.7618e-05, -7.9757e-05, -3.7827e-05,\n",
+       "            4.6473e-05],\n",
+       "          [ 1.9420e-03, -4.4713e-04, -3.9377e-04,  9.0195e-05, -2.2603e-04,\n",
+       "            1.3799e-04]],\n",
+       "\n",
+       "         [[ 5.0055e-04, -1.3916e-04, -9.0930e-05,  3.5967e-05, -9.3951e-05,\n",
+       "            3.6019e-05],\n",
+       "          [-4.2730e-01,  1.2401e-01,  6.7926e-02,  9.8019e-02,  3.6562e-02,\n",
+       "           -4.1228e-02],\n",
+       "          [ 2.1628e-03, -5.2339e-04, -3.9050e-04, -1.6605e-04, -1.2774e-04,\n",
+       "            1.8455e-04],\n",
+       "          [ 4.1095e-04, -1.5755e-04, -4.6207e-06,  6.0032e-06,  7.2175e-06,\n",
+       "            1.0191e-04]],\n",
+       "\n",
+       "         [[ 4.1485e-04, -4.9267e-05, -1.4548e-04, -8.7022e-05, -1.3114e-04,\n",
+       "           -1.9603e-05],\n",
+       "          [-6.9425e-01,  2.0486e-01,  9.8071e-02, -6.1233e-02,  1.3015e-01,\n",
+       "           -8.5667e-02],\n",
+       "          [ 1.7190e-03, -4.3230e-04, -2.8380e-04,  1.9250e-05, -1.8308e-04,\n",
+       "            1.7419e-04],\n",
+       "          [ 3.2231e-03, -9.5350e-04, -4.6478e-04,  2.1273e-04, -4.6348e-04,\n",
+       "            3.3369e-04]]],\n",
+       "\n",
+       "\n",
+       "        [[[ 3.1792e-03, -7.4770e-04, -5.6032e-04,  2.7642e-04, -2.6977e-04,\n",
+       "            2.6633e-04],\n",
+       "          [ 2.7477e-04, -7.6351e-05, -6.5052e-05, -9.9302e-05, -1.0666e-04,\n",
+       "           -1.2732e-05],\n",
+       "          [-1.1154e+00,  3.0467e-01,  1.7338e-01, -3.0910e-02,  1.2295e-01,\n",
+       "           -1.2690e-01],\n",
+       "          [ 3.3784e-03, -8.8567e-04, -5.2169e-04,  1.0223e-04, -1.5988e-04,\n",
+       "            3.2086e-04]],\n",
+       "\n",
+       "         [[ 1.1756e-03, -2.4806e-04, -2.6542e-04, -1.1654e-04, -2.2474e-04,\n",
+       "            7.4703e-05],\n",
+       "          [ 4.4612e-04, -1.6042e-04, -2.6603e-05, -5.0964e-06,  2.1175e-05,\n",
+       "            8.5854e-05],\n",
+       "          [-4.3068e-01,  1.1847e-01,  9.2796e-02,  8.9481e-02,  8.6142e-02,\n",
+       "           -2.5949e-03],\n",
+       "          [ 1.8607e-03, -4.0269e-04, -4.1053e-04, -2.0887e-04, -2.9701e-04,\n",
+       "            1.1739e-04]],\n",
+       "\n",
+       "         [[ 1.4871e-03, -5.0962e-04, -7.2781e-05, -3.2035e-04, -6.3819e-05,\n",
+       "            2.8857e-04],\n",
+       "          [ 8.2991e-04, -1.0379e-04, -2.7100e-04, -1.0666e-04, -1.6331e-04,\n",
+       "           -3.1458e-07],\n",
+       "          [-8.8034e-01,  2.6620e-01,  1.0238e-01,  5.3713e-02,  8.5597e-02,\n",
+       "           -1.3722e-01],\n",
+       "          [ 1.1376e-04,  2.6640e-05, -8.0425e-05,  1.3959e-05, -2.8055e-05,\n",
+       "           -3.0369e-05]],\n",
+       "\n",
+       "         ...,\n",
+       "\n",
+       "         [[ 1.5190e-03, -3.8051e-04, -2.6267e-04, -7.7618e-05, -1.1626e-04,\n",
+       "            1.4749e-04],\n",
+       "          [ 3.7692e-04, -9.8556e-05, -8.3170e-05,  6.1142e-05, -8.9529e-05,\n",
+       "            4.0180e-06],\n",
+       "          [-4.7455e-01,  1.3848e-01,  7.3204e-02,  9.5461e-02,  3.9075e-02,\n",
+       "           -5.0491e-02],\n",
+       "          [ 2.2828e-03, -6.0771e-04, -3.7509e-04, -3.0312e-04, -1.4577e-04,\n",
+       "            2.2117e-04]],\n",
+       "\n",
+       "         [[ 4.2977e-04, -1.1725e-04, -8.0184e-05,  1.8137e-04, -3.0178e-04,\n",
+       "            2.9860e-05],\n",
+       "          [ 2.5958e-04, -9.6915e-05, -1.9576e-05, -1.8288e-04, -5.2471e-05,\n",
+       "            3.7767e-05],\n",
+       "          [-2.0826e+00,  5.2060e-01,  3.5727e-01,  1.2397e-02,  1.8917e-01,\n",
+       "           -1.9168e-01],\n",
+       "          [ 1.6748e-04, -1.3875e-04,  8.5265e-05, -3.9083e-05,  2.1297e-05,\n",
+       "            1.1002e-04]],\n",
+       "\n",
+       "         [[ 1.5209e-04,  2.1059e-06, -6.8081e-05,  4.6900e-05, -1.1646e-04,\n",
+       "           -7.9965e-06],\n",
+       "          [ 4.0711e-04, -1.3331e-04, -4.3223e-05,  1.0461e-04, -1.4958e-04,\n",
+       "            6.0086e-05],\n",
+       "          [-1.4750e+00,  4.0540e-01,  2.0193e-01,  8.3950e-02,  2.0805e-01,\n",
+       "           -1.8369e-01],\n",
+       "          [ 7.6004e-04, -2.0332e-04, -1.3132e-04,  8.6544e-05, -2.1063e-04,\n",
+       "            6.5813e-05]]],\n",
+       "\n",
+       "\n",
+       "        [[[ 7.1276e-03, -1.7017e-03, -1.2255e-03, -1.0974e-04, -4.9669e-04,\n",
+       "            6.2241e-04],\n",
+       "          [ 5.6044e-05, -2.0293e-05, -9.8544e-06, -1.5437e-04, -1.0048e-04,\n",
+       "           -2.4805e-06],\n",
+       "          [ 7.3697e-04, -3.0265e-04, -1.9961e-07,  1.2695e-04, -7.4930e-05,\n",
+       "            1.6868e-04],\n",
+       "          [-2.4059e+00,  5.9870e-01,  4.0599e-01,  5.0456e-02,  2.6623e-01,\n",
+       "           -2.0499e-01]],\n",
+       "\n",
+       "         [[ 3.4030e-03, -8.2061e-04, -6.5051e-04, -3.7691e-05, -4.0012e-04,\n",
+       "            3.0639e-04],\n",
+       "          [ 3.5952e-04, -2.0633e-04,  6.3922e-05,  9.6706e-05,  4.6944e-05,\n",
+       "            1.3051e-04],\n",
+       "          [ 5.4432e-04, -7.8371e-05, -1.7484e-04, -1.8668e-04, -2.6599e-04,\n",
+       "           -1.0395e-05],\n",
+       "          [-1.1583e+00,  3.0865e-01,  1.9246e-01,  8.2751e-02,  1.1228e-01,\n",
+       "           -1.1696e-01]],\n",
+       "\n",
+       "         [[ 7.5073e-05, -4.8714e-05,  2.4298e-05, -1.1636e-04,  2.1185e-05,\n",
+       "            3.7901e-05],\n",
+       "          [ 1.6393e-03, -5.5864e-04, -1.7560e-04, -7.8799e-05,  3.2000e-05,\n",
+       "            2.1644e-04],\n",
+       "          [ 4.1824e-04, -4.1697e-05, -1.4999e-04,  1.2087e-05, -4.5809e-05,\n",
+       "           -1.7206e-05],\n",
+       "          [-3.7783e-01,  1.1708e-01,  4.2571e-02,  3.0614e-02, -1.9066e-02,\n",
+       "           -5.6381e-02]],\n",
+       "\n",
+       "         ...,\n",
+       "\n",
+       "         [[ 2.8411e-03, -7.0228e-04, -5.0224e-04, -1.0907e-04, -2.6384e-04,\n",
+       "            2.6732e-04],\n",
+       "          [ 3.6561e-04, -8.7714e-05, -8.7263e-05,  1.4481e-04, -1.8499e-04,\n",
+       "            1.9218e-06],\n",
+       "          [ 5.3430e-04, -2.0942e-04, -2.7376e-05, -3.0414e-04, -7.0404e-05,\n",
+       "            9.0937e-05],\n",
+       "          [-1.5556e+00,  3.9292e-01,  2.7827e-01,  4.5822e-02,  1.3240e-01,\n",
+       "           -1.3549e-01]],\n",
+       "\n",
+       "         [[ 5.6075e-04, -1.6941e-04, -8.9029e-05,  4.8322e-05, -8.8032e-05,\n",
+       "            4.6820e-05],\n",
+       "          [ 5.2695e-04, -1.5621e-04, -8.0464e-05, -1.1022e-04, -3.7456e-05,\n",
+       "            5.2779e-05],\n",
+       "          [ 1.7827e-03, -5.2826e-04, -2.1241e-04, -4.7995e-05, -3.7495e-05,\n",
+       "            2.3360e-04],\n",
+       "          [-3.4617e-01,  1.2809e-01,  9.3033e-03,  1.9740e-03, -6.7515e-03,\n",
+       "           -8.1594e-02]],\n",
+       "\n",
+       "         [[ 3.1251e-04,  8.0040e-06, -1.4258e-04, -1.7304e-04, -1.3081e-04,\n",
+       "           -1.6578e-05],\n",
+       "          [ 1.9248e-03, -6.6573e-04, -1.6596e-04,  2.7122e-04, -3.6531e-04,\n",
+       "            3.1055e-04],\n",
+       "          [ 1.9173e-03, -4.7141e-04, -3.2948e-04, -2.7374e-06, -2.1952e-04,\n",
+       "            1.8361e-04],\n",
+       "          [-1.0630e+00,  2.8486e-01,  1.8316e-01, -2.9499e-02,  1.7082e-01,\n",
+       "           -9.2339e-02]]]], grad_fn=<UnsafeViewBackward>)"
+      ]
+     },
+     "metadata": {},
+     "execution_count": 20
+    }
+   ],
+   "source": [
+    "wf.ao2mo(wf.ao(pos,1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "2 torch.Size([11, 4, 6])\n2 torch.Size([12, 11, 4, 6])\n2 torch.Size([12, 11, 4, 6])\n"
+     ]
+    },
+    {
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "tensor([[ -5.6052],\n",
+       "        [ -6.1737],\n",
+       "        [ -0.9758],\n",
+       "        [  4.1463],\n",
+       "        [-10.8037],\n",
+       "        [  3.9504],\n",
+       "        [ -2.8118],\n",
+       "        [ -7.6169],\n",
+       "        [ -9.7781],\n",
+       "        [ -0.5639],\n",
+       "        [ -1.5769]], grad_fn=<MulBackward0>)"
+      ]
+     },
+     "metadata": {},
+     "execution_count": 27
+    }
+   ],
+   "source": [
+    "wf.kinetic_energy(pos)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ]
+}
\ No newline at end of file
diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 1c88fa72..a701e0b7 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,18 +1,21 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
-
 from .__version__ import __version__
 
+
 __author__ = "Nicolas Renaud"
-__email__ = 'n.renaud@esciencecenter.nl'
+__email__ = "n.renaud@esciencecenter.nl"
 
 import twiggy
 import sys
+
 twiggy.quick_setup(file=sys.stdout)
-log = twiggy.log.name('QMCTorch')
+log = twiggy.log.name("QMCTorch")
 log.min_level = twiggy.levels.INFO
 
 log.info(r"  ____    __  ______________             _")
 log.info(r" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
 log.info(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
 log.info(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
+log.info("")
+log.info("{0}", __version__)
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 73e3bb4f..5ebd7d19 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = "0.3.2"
\ No newline at end of file
diff --git a/qmctorch/ase/__init__.py b/qmctorch/ase/__init__.py
new file mode 100644
index 00000000..3ac3ba05
--- /dev/null
+++ b/qmctorch/ase/__init__.py
@@ -0,0 +1 @@
+from .ase import QMCTorch 
\ No newline at end of file
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
new file mode 100644
index 00000000..6203a13c
--- /dev/null
+++ b/qmctorch/ase/ase.py
@@ -0,0 +1,582 @@
+from ase.calculators.calculator import Calculator, all_changes
+from ase import Atoms
+import numpy as np
+import torch
+from torch import optim
+from types import SimpleNamespace
+
+from ..utils import set_torch_double_precision
+from ..utils.constants import ANGS2BOHR
+from ..scf.molecule import Molecule as SCF
+from ..wavefunction.slater_jastrow import SlaterJastrow
+from ..wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from ..wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from ..solver import Solver
+from ..sampler import Metropolis
+from ..sampler.symmetry import C1
+from .. import log
+
+class QMCTorch(Calculator):
+
+    implemented_properties = ["energy", "forces"]
+
+    def __init__(self,
+                 restart: str = None,
+                 *,
+                 labels: list = None,
+                 atoms: Atoms = None,
+                 **kwargs: dict) -> None:
+        """
+        Initialize a QMCTorchCalculator object.
+
+        Parameters
+        ----------
+        restart : str, optional
+            Filename to read the calculator from.  If not given,
+            an initial calculation will be performed.
+        labels : list of str, optional
+            List of labels.  If not given, atoms will be used
+            to set initial labels.
+        atoms : Atoms object, optional
+            The initial atomic configuration.
+        **kwargs : dict
+            Additional keyword arguments are passed to the
+            SCF, WF, Sampler, Optimizer and Solver objects.
+
+        Returns
+        -------
+        None
+        """
+        Calculator.__init__(self, restart=restart, labels=labels, atoms=atoms)
+        self.use_cuda = torch.cuda.is_available()
+        set_torch_double_precision()
+        self.has_forces = False
+
+        # default options for the SCF
+        self.molecule = None
+        self.scf_options = SimpleNamespace(calculator='pyscf',
+                                           basis='dzp',
+                                           scf='hf')
+        self.recognized_scf_options = list(self.scf_options.__dict__.keys())
+        
+        
+        # default options for the WF
+        self.wf = None
+        self.wf_options = SimpleNamespace(kinetic='jacobi',
+                                          configs='single_double(2,2)',
+                                          orthogonalize_mo=True,
+                                          mix_mo = False,
+                                          include_all_mo=True,
+                                          cuda=self.use_cuda,
+                                          jastrow=SimpleNamespace(
+                                              kernel=PadeJastrowKernel,
+                                              kernel_kwargs={'w':1.00},
+                                          ),
+                                          backflow=SimpleNamespace(
+                                              kernel=BackFlowKernelInverse,
+                                              kernel_kwargs={'weight':1.00},
+                                          ),
+                                          gto2sto=False)
+
+        self.recognized_wf_options = list(self.wf_options.__dict__.keys())  
+        self.recognized_jastrow_options = list(self.wf_options.jastrow.__dict__.keys())
+        self.recognized_backflow_options = list(self.wf_options.backflow.__dict__.keys())
+        self.wf_options.backflow = None
+
+        # default option for the sampler
+        self.sampler = None
+        self.sampler_options = SimpleNamespace(nwalkers=4000, nstep=2000, 
+                                               ntherm=-1, ndecor=1, step_size=0.05,
+                                               symmetry=None)
+        self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
+        
+        
+        # optimizer .... 
+        self.optimizer = None
+
+        # default option for the solver
+        self.solver = None
+        self.solver_options = SimpleNamespace(track=['local_energy', 'parameters'], freeze=[],
+                                              loss='energy', grad='manual',
+                                              ortho_mo=False, clip_loss=False,
+                                              resampling=SimpleNamespace(mode='update', 
+                                                                         resample_every=1, 
+                                                                         nstep_update=50, 
+                                                                         ntherm_update=-1),
+                                              niter=100, tqdm=False)
+        self.recognized_solver_options = list(self.solver_options.__dict__.keys())
+        self.recognized_resampling_options = list(self.solver_options.resampling.__dict__.keys())
+        
+        # default symmetry
+        self.symmetry = C1()
+
+    @staticmethod
+    def validate_options(options: SimpleNamespace, recognized_options: list, name: str = "") -> None:
+        """
+        Validate that the options provided are valid.
+
+        Parameters
+        ----------
+        options : SimpleNamespace
+            The options to be validated.
+        recognized_options : list
+            The recognized options.
+        name : str, optional
+            The name of the options to be validated.
+
+        Raises
+        ------
+        ValueError
+            If the options contain invalid options.
+
+        Returns
+        -------
+        None
+        """
+        for opt in list(options.__dict__.keys()):
+            if opt not in recognized_options:
+                raise ValueError(
+                    "Invalid %s options: %s. Recognized options are %s" % (name, opt, recognized_options)
+                )
+
+    def run_scf(self) -> None:
+        """
+        Set a default molecule called SCF here object. If the atoms object is not set, it raises
+        a ValueError.
+
+        The default molecule is created by writing the atoms object to a file
+        named '<name>.xyz' and then loading this file into a Molecule(SCF)
+        object.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        self.validate_options(self.scf_options, self.recognized_scf_options, 'SCF')
+
+        if self.atoms is None:
+            raise ValueError("Atoms object is not set")
+        filename = self.atoms.get_chemical_formula() + '.xyz'
+        self.atoms.write(filename) 
+        self.molecule = SCF(atom=filename, 
+                                 unit='angs', 
+                                 scf=self.scf_options.scf,
+                                 calculator=self.scf_options.calculator, 
+                                 basis=self.scf_options.basis, redo_scf=True)
+
+    def set_wf(self) -> None:
+        """
+        Set the default wave function for the QMCTorchCalculator.
+
+        This method initializes a Slater-Jastrow wave function for the current molecule.
+        It uses a specific configuration for the wave function and sets up a Jastrow
+        factor with a PadeJastrowKernel. The method requires that a molecule object
+        is already set; otherwise, it raises a ValueError.
+
+        Raises:
+            ValueError: If the molecule object is not set.
+        """
+        # check if molecuyle is set
+        if self.molecule is None:
+            raise ValueError("Molecule object is not set")
+        
+        # check jastrow and set it
+        if self.wf_options.jastrow is not None:
+            self.validate_options(self.wf_options.jastrow, self.recognized_jastrow_options, 'Jastrow')
+            jastrow = JastrowFactor(self.molecule, self.wf_options.jastrow.kernel, 
+                                    self.wf_options.jastrow.kernel_kwargs, cuda=self.use_cuda)
+        else:
+            jastrow = None
+
+        # check backflow and set it
+        if self.wf_options.backflow is not None:
+            self.validate_options(self.wf_options.backflow, self.recognized_backflow_options, 'Backflow')
+            backflow = BackFlowTransformation(self.molecule, self.wf_options.backflow.kernel, 
+                                              self.wf_options.backflow.kernel_kwargs, cuda=self.use_cuda)
+        else:
+            backflow = None
+
+        #checlk wf options and set wf
+        self.validate_options(self.wf_options, self.recognized_wf_options, 'WF')
+        self.wf = SlaterJastrow(mol=self.molecule,
+                                kinetic=self.wf_options.kinetic,
+                                configs=self.wf_options.configs,
+                                backflow=backflow,
+                                jastrow=jastrow,
+                                mix_mo=self.wf_options.mix_mo,
+                                orthogonalize_mo=self.wf_options.orthogonalize_mo,
+                                include_all_mo=self.wf_options.include_all_mo,
+                                cuda=self.use_cuda)
+        
+        # in case we want a sto transform
+        if self.wf_options.gto2sto:
+            if self.scf_options.calculator != 'pyscf':
+                raise ValueError("gto2sto is only supported for pyscf")
+            self.wf = self.wf.gto2sto()
+
+    def set_sampler(self) -> None:
+        """
+        Set default sampler object.
+
+        Parameters
+        ----------
+        None
+
+        Notes
+        -----
+        The default sampler object is a Metropolis object with 4000 walkers,
+        2000 steps, a step size of 0.05, and one decorrelation step.
+        The sampler is initialized with atomic positions.
+        If self.use_cud is True, the sampler will use the GPU.
+        """
+        if self.wf is None:
+            raise ValueError("Wave function object is not set")
+        self.validate_options(self.sampler_options, self.recognized_sampler_options, 'Sampler')
+        self.sampler = Metropolis(nwalkers=self.sampler_options.nwalkers, nstep=self.sampler_options.nstep, 
+                                  nelec=self.wf.nelec, ntherm=self.sampler_options.ntherm, ndecor=self.sampler_options.ndecor,
+                                  step_size=self.sampler_options.step_size, init=self.molecule.domain('atomic'),
+                                  symmetry=self.sampler_options.symmetry, cuda=self.use_cuda)
+        
+    def set_default_optimizer(self) -> None:
+        if self.wf is None:
+            raise ValueError("Wave function object is not set")
+        lr_dict = [{'params': self.wf.jastrow.parameters(), 'lr': 1E-2},
+                {'params': self.wf.ao.parameters(), 'lr': 1E-2},
+                {'params': self.wf.mo.parameters(), 'lr': 1E-2},
+                {'params': self.wf.fc.parameters(), 'lr': 1E-2}]
+        self.optimizer = optim.Adam(lr_dict, lr=1E-2)
+
+
+    def set_resampling_options(self) -> None:
+        """
+        Configure the resampling options for the solver.
+
+        This method sets the number of Monte Carlo steps (`nstep_update`) to be used 
+        during the resampling process based on the current sampler and solver options. 
+        It calculates the number of sampling steps after thermalization and updates 
+        the `nstep_update` value if the resampling mode is 'update'.
+
+        Notes
+        -----
+        - The method will adjust `nstep_update` only if the `ntherm` value is not -1 
+        and the resampling mode is set to 'update'.
+        - The calculation for `nstep_update` considers the difference between `nstep` 
+        and `ntherm`, added to `ntherm_update`.
+
+        """
+
+        if (self.sampler_options.ntherm != -1) and (self.solver_options.resampling.mode == 'update'):
+            nsample = self.sampler_options.nstep - self.sampler_options.ntherm
+            self.solver_options.resampling.nstep_update = self.solver_options.resampling.ntherm_update + nsample
+
+        elif (self.sampler_options.ntherm == -1) and (self.solver_options.resampling.mode == 'update'):
+            if self.solver_options.resampling.ntherm_update != -1:
+                self.solver_options.resampling.ntherm_update = -1
+
+    def initialize(self) -> None:
+        """
+        Set the default solver object for the QMCTorchCalculator.
+
+        This method initializes the default Solver object for the QMCTorchCalculator.
+        It first checks if the wave function, sampler, and optimizer objects are set,
+        and if not, it initializes them with default values. It then sets up the Solver
+        object with those defaults. The method also sets the parameters that require
+        gradient computation and the configuration for the solver.
+
+        Parameters
+        ----------
+        None
+
+        Notes
+        -----
+        The default configuration for the solver is set to track the local energy and
+        the parameters of the wave function, with no frozen parameters. The gradient
+        computation is set to manual, and the resampling is set to update every step.
+        """
+        if self.molecule is None:
+            self.run_scf()
+
+        if self.wf is None:
+            self.set_wf()
+        
+        if self.sampler is None:
+            self.set_sampler()
+
+        if self.optimizer is None:
+            self.set_default_optimizer()
+        
+        self.validate_options(self.solver_options, self.recognized_solver_options, 'Solver')
+        self.validate_options(self.solver_options.resampling, self.recognized_resampling_options, 'Resampling')
+        
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.optimizer, scheduler=None)
+        self.set_resampling_options()
+
+        self.solver.configure(track=self.solver_options.track, freeze=self.solver_options.freeze,
+                loss=self.solver_options.loss, grad=self.solver_options.grad,
+                ortho_mo=self.solver_options.ortho_mo, clip_loss=self.solver_options.clip_loss,
+                resampling=self.solver_options.resampling.__dict__
+                )
+
+    def set_atoms(self, atoms: Atoms) -> None:
+        """
+        Set atoms object.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object
+            The atoms object to be set.
+        """
+        self.atoms = atoms
+
+
+    def reset(self) -> None:
+        """
+        Reset the internal state of the QMCTorchCalculator.
+
+        This method resets the internal state of the calculator by clearing
+        the current atoms, wave function, molecule, sampler, and solver objects.
+        It also sets the `has_forces` attribute to False and calls `reset_results`
+        to clear the results dictionary. This is typically used to reinitialize
+        the calculator to a clean state before performing new calculations.
+        """
+        self.atoms = None
+        self.wf = None
+        self.molecule = None
+        self.sampler = None
+        self.solver = None
+        self.has_forces = False
+        self.reset_results()
+
+    def reset_results(self) -> None:
+        """
+        Reset the results dictionary.
+
+        This method clears the current results stored in the calculator by
+        setting the results dictionary to an empty state. It is typically 
+        used when reinitializing the calculator or after a calculation to 
+        ensure that previous results do not affect future computations.
+        """
+        self.results = {}
+
+    def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
+        """
+        Update the calculator.
+
+        This method checks if the solver has been set. If not, it sets the atoms object
+        (if provided) and initializes the solver. If the solver has been set, it checks
+        if the atomic positions have changed. If they have, it resets the calculator and
+        sets the new atoms object and the solver again.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object, optional
+            The atoms object to be set. If not provided, the calculator will not be reset.
+        force : bool
+            If True, the solver will be reset even if the atomic positions have not changed.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method is typically called before calculating a quantity.
+        """
+        if atoms is not None:
+            if not np.allclose(self.atoms.get_positions() * ANGS2BOHR, np.array(self.molecule.atom_coords)):
+                self.reset()
+                self.set_atoms(atoms)
+                self.initialize()
+        else:
+            if self.solver is None:
+                self.initialize()
+
+    def calculate(self, atoms: Atoms = None, properties: 
+                  list = ['energy'], system_changes: any = None) -> float:
+        """
+        Calculate specified properties for the given atomic configuration.
+
+        This method computes the requested properties, such as energy or forces, 
+        for the provided Atoms object. It ensures the solver is reset if the atomic 
+        configuration changes and checks that all requested properties are implemented.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object, optional
+            The atomic configuration for which the properties should be calculated. 
+            If not provided, the current atoms object associated with the calculator 
+            is used.
+        properties : list of str, optional
+            A list of properties to calculate. Supported properties are 'energy' 
+            and 'forces'. Default is ['energy'].
+        system_changes : any, optional
+            Information about the changes in the atomic system. Default is None.
+
+        Returns
+        -------
+        float
+            The computed value of the requested property.
+
+        Raises
+        ------
+        ValueError
+            If a requested property is not recognized or not implemented.
+
+        Notes
+        -----
+        The method first resets the solver if needed, checks the validity of the 
+        requested properties, and then computes each property one-by-one.
+        """
+
+        # reset the solver if needed
+        self.reset_solver(atoms=atoms)
+
+        # check properties that are needed
+        if any([p not in self.implemented_properties for p in properties]):
+            raise ValueError('property not recognized')
+        
+        # compute
+        for p in properties:
+            if p == 'forces':
+                return self._calculate_forces(atoms=atoms)
+
+            elif p == 'energy':
+                return self._calculate_energy(atoms=atoms)
+
+    def _calculate_energy(self, atoms: Atoms =None) -> float:
+        # check if reset is necessary 
+        """
+        Compute the energy using the wave function and the atomic positions.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object, optional
+            The atoms object to be used for the computation. If not provided, the calculator 
+            will use the atoms object that was set when the calculator was created.
+
+        Returns
+        -------
+        energy : float
+            The computed energy.
+
+        Notes
+        -----
+        This method first resets the solver (if necessary), then sets the wave function parameters
+        as the only parameters that require gradient computation. It then runs the optimization
+        for the specified number of iterations (with tqdm if specified), and finally computes the
+        energy of the system. The result is stored in the calculator's results dictionary and
+        returned.
+        """
+        # optimize the wave function
+        if self.solver_options.niter > 0:
+            self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+            self.solver.freeze_parameters(self.solver_options.freeze)
+            self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+
+        # compute the energy 
+        observable = self.solver.single_point()
+
+        # store and output
+        self.results['energy'] = observable.energy
+        return self.results['energy']
+
+    def _calculate_forces(self, atoms: Atoms = None) -> float:
+
+        # check if reset is necessary
+        """
+        Compute the forces using the wave function and the atomic positions.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object, optional
+            The atoms object to be used for the computation. If not provided, the calculator 
+            will use the atoms object that was set when the calculator was created.
+
+        Returns
+        -------
+        forces : numpy.ndarray
+            The computed forces, with the same shape as the positions of the atoms object.
+
+        Notes
+        -----
+        The forces are computed by optimizing the wave function using the atomic positions as variational parameters.
+        """
+
+        # optimize the wave function
+        if self.solver_options.niter > 0:
+            self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+            self.solver.freeze_parameters(self.solver_options.freeze)
+            self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+
+        # resample
+        observable = self.solver.single_point()
+
+        # compute the forces 
+        forces = self.solver.compute_forces(self.symmetry(observable.pos)).detach().cpu().numpy()
+
+        # store and output
+        self.results['energy'] = observable.energy.cpu().numpy()
+        self.results['forces'] = forces
+        self.solver.wf.zero_grad()
+
+        self.has_forces = True
+        return self.results['forces']
+
+    def check_forces(self) -> bool:
+        """
+        Check if the forces have been computed.
+
+        Returns
+        -------
+        bool
+            True if the forces have been computed, False otherwise.
+        """
+        if (self.has_forces) and ('forces' in self.results):
+            return True
+        self.has_forces = False
+        return False
+    
+    def get_forces(self, atoms: Atoms = None) -> np.ndarray:
+        """
+        Return the total forces.
+
+        Parameters
+        ----------
+        atoms : ase.Atoms
+            The ASE atoms object. If not provided, the internal atoms object is used.
+
+        Returns
+        -------
+        forces : array
+            The total forces on the atoms.
+        """
+        
+        self.reset_solver(atoms=atoms)
+        if self.check_forces():
+            return self.results['forces']
+        else:
+            return self._calculate_forces(atoms=atoms)
+    
+    def get_total_energy(self, atoms: Atoms=None) -> float:
+        """
+        Return the total energy.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object, optional
+            The atoms object to be used for the calculation.
+
+        Returns
+        -------
+        energy : float
+            The total energy of the system.
+        """
+        self.reset_solver(atoms=atoms)
+        if 'energy' in self.results:
+            return self.results['energy']
+        else:
+            return self._calculate_energy(atoms=atoms)
\ No newline at end of file
diff --git a/qmctorch/ase/optimizer/__init__.py b/qmctorch/ase/optimizer/__init__.py
new file mode 100644
index 00000000..fc36af9c
--- /dev/null
+++ b/qmctorch/ase/optimizer/__init__.py
@@ -0,0 +1 @@
+from .torch_optim import TorchOptimizer
\ No newline at end of file
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
new file mode 100644
index 00000000..55456cca
--- /dev/null
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -0,0 +1,159 @@
+from typing import IO, Any, Callable, Dict, List, Optional, Union
+from types import SimpleNamespace
+from torch.optim import SGD
+from torch.optim import Optimizer as torch_optimizer
+import numpy as np
+import time
+from math import sqrt
+from copy import deepcopy
+from ase import Atoms
+from ase.optimize.optimize import Optimizer
+from ase.utils import deprecated
+from ...utils.constants import BOHR2ANGS 
+class TorchOptimizer(Optimizer):
+
+    def __init__(self, 
+                 atoms:Atoms,
+                 optimizer: Optional[torch_optimizer] = None,
+                 nepoch_wf_init: Optional[int] = 100,
+                 nepoch_wf_update: Optional[int] = 10,
+                 batchsize: Optional[int] = None,
+                 tqdm: Optional[bool] = False,
+                 restart: Optional[str] = None,
+                 logfile: Union[IO, str] = '-',
+                 trajectory: Optional[str] = None,
+                 master: Optional[bool] = None):
+        
+
+        Optimizer.__init__(self, atoms, restart, logfile, trajectory,
+                           master)
+        
+        self.opt_geo = optimizer
+        self.batchsize = batchsize
+        self.tqdm = tqdm
+        self.nepoch_wf_init = nepoch_wf_init
+        self.nepoch_wf_update = nepoch_wf_update
+        self.xyz_trajectory = None
+
+    def log(self, e: float, forces: np.ndarray) -> float:
+        """
+        Write to the log file.
+
+        Parameters
+        ----------
+        e : float
+            Energy of the system.
+        forces : np.ndarray
+            Forces on the atoms.
+
+        Returns
+        -------
+        fmax : float
+            Maximum force on any atom.
+
+        Notes
+        -----
+        This function is called by the optimizer at each step. It writes the
+        energy, forces, and time to the log file.
+        """
+        fmax = sqrt((forces ** 2).sum(axis=1).max())
+        T = time.localtime()
+        if self.logfile is not None:
+            name = self.__class__.__name__
+            if self.nsteps == 0:
+                args = (" " * len(name), "Step", "Time", "Energy", "fmax")
+                msg = "%s  %4s %8s %15s  %12s\n" % args
+                self.logfile.write(msg)
+
+            args = (name, self.nsteps, T[3], T[4], T[5], e, fmax)
+            msg = "%s:  %3d %02d:%02d:%02d %15.6f %15.6f\n" % args
+            self.logfile.write(msg)
+            self.logfile.flush()
+        return fmax
+    
+    def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> SimpleNamespace:
+        """
+        Run a geometry optimization.
+
+        Parameters
+        ----------
+        fmax : float
+            Convergence criteria for the forces.
+        steps : int, optional
+            Number of optimization steps. Defaults to 10.
+        hdf5_group : str, optional
+            HDF5 group where the data is stored. Defaults to 'geo_opt'.
+
+        Returns
+        -------
+        observable : Observable
+            The observable instance containing the optimized geometry.
+
+        Notes
+        -----
+        The geometry optimization is done in two steps. First, the wave function
+        is optimized using the method specified in the Solver instance, then
+        the geometry is optimized using the provided optimizer. The process is
+        repeated until convergence or until the specified number of iterations
+        is reached.
+        """
+        solver = self.atoms.calc.solver
+
+        if self.opt_geo is None:
+            self.opt_geo = SGD(solver.wf.parameters(), lr=1E-2)
+            self.opt_geo.lpos_needed = False
+
+        # save the optimizer used for the wf params
+        self.opt_wf = deepcopy(solver.opt)
+        self.opt_wf.lpos_needed = solver.opt.lpos_needed
+
+        # save the grad method
+        self.eval_grad_wf = solver.evaluate_gradient
+
+        # log data
+        solver.prepare_optimization(self.batchsize, None, self.tqdm)
+        solver.log_data_opt(steps, "geometry optimization")
+
+        # init the traj
+        self.xyz_trajectory = [solver.wf.geometry(None)]
+
+        # initial wf optimization
+        solver.set_params_requires_grad(wf_params=True, geo_params=False)
+        solver.freeze_parameters(solver.freeze_params_list)
+        solver.run_epochs(self.nepoch_wf_init)
+
+        for n in range(steps):
+
+            # one step of geo optim
+            solver.set_params_requires_grad(wf_params=False, geo_params=True)
+            solver.opt = self.opt_geo
+            solver.evaluate_gradient = solver.evaluate_grad_auto # evaluate_grad_manual not valid for forces
+            solver.run_epochs(1, verbose=False)
+            forces = solver.wf.forces()
+            print(solver.wf.geometry(None,convert_to_angs=True))
+            self.xyz_trajectory.append(solver.wf.geometry(None,convert_to_angs=True))
+
+            # make a few wf optim
+            solver.set_params_requires_grad(wf_params=True, geo_params=False)
+            solver.freeze_parameters(solver.freeze_params_list)
+            solver.opt = self.opt_wf
+            solver.evaluate_gradient = self.eval_grad_wf
+            cumulative_loss = solver.run_epochs(self.nepoch_wf_update, 
+                                                with_tqdm=self.tqdm, verbose=False)
+
+            # update the geometry
+            self.optimizable.set_positions(solver.wf.geometry(None,convert_to_angs=True))
+            current_fmax = self.log(cumulative_loss, forces)
+            self.call_observers()
+
+            if current_fmax < fmax:
+                break
+
+        # restore the sampler number of step
+        solver.restore_sampling_parameters()
+
+        # dump
+        solver.observable.geometry = self.xyz_trajectory
+        solver.save_data(hdf5_group)
+
+        return solver.observable
diff --git a/qmctorch/sampler/__init__.py b/qmctorch/sampler/__init__.py
index cc322b98..6a58bffc 100644
--- a/qmctorch/sampler/__init__.py
+++ b/qmctorch/sampler/__init__.py
@@ -1,10 +1,15 @@
 __all__ = [
-    'SamplerBase',
-    'Metropolis',
-    'Hamiltonian',
-    'GeneralizedMetropolis']
+    "SamplerBase",
+    "Metropolis",
+    "Hamiltonian",
+    "PintsSampler",
+    "MetropolisHasting",
+    "GeneralizedMetropolis",
+]
 
 from .sampler_base import SamplerBase
 from .metropolis import Metropolis
 from .hamiltonian import Hamiltonian
 from .generalized_metropolis import GeneralizedMetropolis
+from .pints_sampler import PintsSampler
+from .metropolis_hasting_all_elec import MetropolisHasting
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 93718884..50d088c7 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -1,4 +1,5 @@
 from tqdm import tqdm
+from typing import Dict, Any, Callable, Optional
 import torch
 from torch.autograd import Variable, grad
 from torch.distributions import MultivariateNormal
@@ -9,44 +10,54 @@
 
 
 class GeneralizedMetropolis(SamplerBase):
-
-    def __init__(self, nwalkers=100, nstep=1000, step_size=3,
-                 ntherm=-1, ndecor=1,
-                 nelec=1, ndim=1,
-                 init={'type': 'uniform', 'min': -5, 'max': 5},
-                 cuda=False):
+    def __init__(  # pylint: disable=dangerous-default-value
+        self,
+        nwalkers: int = 100,
+        nstep: int = 1000,
+        step_size: float = 3,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 1,
+        init: Dict[str, Any] = {"type": "uniform", "min": -5, "max": 5},
+        cuda: bool = False,
+    ) -> None:
         """Generalized Metropolis Hasting sampler
 
         Args:
             nwalkers (int, optional): number of walkers. Defaults to 100.
             nstep (int, optional): number of steps. Defaults to 1000.
-            step_size (int, optional): size of the steps. Defaults to 3.
+            step_size (float, optional): size of the steps. Defaults to 3.
             ntherm (int, optional): number of steps for thermalization. Defaults to -1.
             ndecor (int, optional): number of steps for decorelation. Defaults to 1.
             nelec (int, optional): number of electron. Defaults to 1.
             ndim (int, optional): number of dimensions. Defaults to 1.
             init (dict, optional): method to initialize the walkers. Defaults to {'type': 'uniform', 'min': -5, 'max': 5}.
             cuda (bool, optional): use cuda. Defaults to False.
+
+        Returns:
+            None
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             step_size, ntherm, ndecor, nelec, ndim, init,
-                             cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
-    def __call__(self, pdf, pos=None, with_tqdm=True):
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
+                 pos: Optional[torch.Tensor] = None,
+                 with_tqdm: bool = True) -> torch.Tensor:
         """Generate a series of point using MC sampling
 
         Args:
             pdf (callable): probability distribution function to be sampled
-            pos (torch.tensor, optional): position to start with.
+            pos (torch.Tensor, optional): position to start with.
                                           Defaults to None.
             with_tqdm (bool, optional): use tqdm to monitor progress
 
         Returns:
-            torch.tensor: positions of the walkers
+            torch.Tensor: positions of the walkers
         """
         with torch.no_grad():
-
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
@@ -58,22 +69,23 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
             rhoi = pdf(xi)
             drifti = self.get_drift(pdf, xi)
 
-            rhoi[rhoi == 0] = 1E-16
+            rhoi[rhoi == 0] = 1e-16
             pos, rate, idecor = [], 0, 0
 
-            rng = tqdm(range(self.nstep),
-                       desc='INFO:QMCTorch|  Sampling',
-                       disable=not with_tqdm)
+            rng = tqdm(
+                range(self.nstep),
+                desc="INFO:QMCTorch|  Sampling",
+                disable=not with_tqdm,
+            )
 
             for istep in rng:
-
                 # new positions
                 xf = self.move(drifti)
 
                 # new function
                 rhof = pdf(xf)
                 driftf = self.get_drift(pdf, xf)
-                rhof[rhof == 0.] = 1E-16
+                rhof[rhof == 0.0] = 1e-16
 
                 # transtions
                 Tif = self.trans(xi, xf, driftf)
@@ -84,86 +96,95 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
                 index = self._accept(pmat)
 
                 # acceptance rate
-                rate += index.byte().sum().float() / self.nwalkers
+                rate += index.byte().sum().float() / self.walkers.nwalkers
 
                 # update position/function value
                 xi[index, :] = xf[index, :]
                 rhoi[index] = rhof[index]
-                rhoi[rhoi == 0] = 1E-16
+                rhoi[rhoi == 0] = 1e-16
 
                 drifti[index, :] = driftf[index, :]
 
-                if (istep >= self.ntherm):
-                    if (idecor % self.ndecor == 0):
+                if istep >= self.ntherm:
+                    if idecor % self.ndecor == 0:
                         pos.append(xi.clone().detach())
                     idecor += 1
 
-            log.options(style='percent').debug("  Acceptance rate %1.3f" %
-                                               (rate / self.nstep * 100))
+            log.options(style="percent").debug(
+                "  Acceptance rate %1.3f" % (rate / self.nstep * 100)
+            )
 
             self.walkers.pos.data = xi.data
 
         return torch.cat(pos).requires_grad_()
 
-    def move(self, drift):
+    def move(self, drift: torch.Tensor) -> torch.Tensor:
         """Move electron one at a time in a vectorized way.
 
         Args:
-            drift (torch.tensor): drift velocity of the walkers
+            drift (torch.Tensor): drift velocity of the walkers
 
         Returns:
-            torch.tensor: new positions of the walkers
+            torch.Tensor: new positions of the walkers
         """
 
-        # clone and reshape data : Nwlaker, Nelec, Ndim
+        # Clone and reshape data to (nwalkers, nelec, ndim)
         new_pos = self.walkers.pos.clone()
-        new_pos = new_pos.view(self.nwalkers,
-                               self.nelec, self.ndim)
+        new_pos = new_pos.view(self.walkers.nwalkers, self.nelec, self.ndim)
 
-        # get indexes
-        index = torch.LongTensor(self.nwalkers).random_(
-            0, self.nelec)
+        # Get random indices for electrons to move
+        index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
 
-        new_pos[range(self.nwalkers), index,
-                :] += self._move(drift, index)
+        # Update positions of selected electrons
+        new_pos[range(self.walkers.nwalkers), index, :] += self._move(drift, index)
 
-        return new_pos.view(self.nwalkers, self.nelec * self.ndim)
+        # Return reshaped positions
+        return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
-    def _move(self, drift, index):
+    def _move(
+        self, drift: torch.Tensor, index: int
+    ) -> torch.Tensor:
         """Move a walker.
 
         Args:
-            drift (torch.tensor): drift velocity
-            index (int): indx of the electron to move
+            drift (torch.Tensor): drift velocity
+            index (int): index of the electron to move
 
         Returns:
-            torch.tensor: position of the walkers
+            torch.Tensor: position of the walkers
         """
 
-        d = drift.view(self.nwalkers,
-                       self.nelec, self.ndim)
+        # Reshape drift to (nwalkers, nelec, ndim)
+        d = drift.view(self.walkers.nwalkers, self.nelec, self.ndim)
 
-        mv = MultivariateNormal(torch.zeros(self.ndim), np.sqrt(
-            self.step_size) * torch.eye(self.ndim))
+        # Create a multivariate normal distribution with mean 0 and variance step_size
+        mv = MultivariateNormal(
+            torch.zeros(self.ndim), np.sqrt(self.step_size) * torch.eye(self.ndim)
+        )
 
-        return self.step_size * d[range(self.nwalkers), index, :] \
-            + mv.sample((self.nwalkers, 1)).squeeze()
+        # Add the drift to the random normal variable
+        return (
+            self.step_size * d[range(self.walkers.nwalkers), index, :]
+            + mv.sample((self.walkers.nwalkers, 1)).squeeze()
+        )
 
-    def trans(self, xf, xi, drifti):
-        """transform the positions
+    def trans(self, xf: torch.Tensor, xi: torch.Tensor, drifti: torch.Tensor) -> torch.Tensor:
+        """Transform the positions
 
         Args:
-            xf ([type]): [description]
-            xi ([type]): [description]
-            drifti ([type]): [description]
+            xf (torch.Tensor): Final positions
+            xi (torch.Tensor): Initial positions
+            drifti (torch.Tensor): Drift velocity
 
         Returns:
-            [type]: [description]
+            torch.Tensor: Transition probabilities
         """
         a = (xf - xi - drifti * self.step_size).norm(dim=1)
-        return torch.exp(- 0.5 * a / self.step_size)
+        return torch.exp(-0.5 * a / self.step_size)
 
-    def get_drift(self, pdf, x):
+    def get_drift(
+        self, pdf: Callable[[torch.Tensor], torch.Tensor], x: torch.Tensor
+    ) -> torch.Tensor:
         """Compute the drift velocity
 
         Args:
@@ -174,25 +195,22 @@ def get_drift(self, pdf, x):
             torch.tensor: drift velocity
         """
         with torch.enable_grad():
-
             x.requires_grad = True
             rho = pdf(x).view(-1, 1)
             z = Variable(torch.ones_like(rho))
-            grad_rho = grad(rho, x,
-                            grad_outputs=z,
-                            only_inputs=True)[0]
+            grad_rho = grad(rho, x, grad_outputs=z, only_inputs=True)[0]
             return 0.5 * grad_rho / rho
 
-    def _accept(self, P):
-        """accept the move or not
+    def _accept(self, P: torch.Tensor) -> torch.Tensor:
+        """Accept the move or not
 
         Args:
-            P (torch.tensor): probability of each move
+            P (torch.Tensor): probability of each move
 
         Returns:
-            torch.tensor: the indx of the accepted moves
+            torch.Tensor: the index of the accepted moves
         """
         P[P > 1] = 1.0
-        tau = torch.rand(self.walkers.nwalkers).double()
+        tau = torch.rand(self.walkers.nwalkers, dtype=torch.float64)
         index = (P - tau >= 0).reshape(-1)
         return index.type(torch.bool)
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 22496181..96b9a146 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -1,4 +1,4 @@
-from typing import Dict
+from typing import Dict, Callable, Optional, Tuple
 
 import torch
 from tqdm import tqdm
@@ -8,18 +8,19 @@
 
 
 class Hamiltonian(SamplerBase):
-
-    def __init__(self,
-                 nwalkers: int = 100,
-                 nstep: int = 100,
-                 step_size: float = 0.2,
-                 L: int = 10,
-                 ntherm: int = -1,
-                 ndecor: int = 1,
-                 nelec: int = 1,
-                 ndim: int = 3,
-                 init: Dict = {'min': -5, 'max': 5},
-                 cuda: bool = False):
+    def __init__(
+        self,
+        nwalkers: int = 100,
+        nstep: int = 100,
+        step_size: float = 0.2,
+        L: int = 10,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Dict = {"min": -5, "max": 5},
+        cuda: bool = False,
+    ):
         """Hamiltonian Monte Carlo Sampler.
 
         Args:
@@ -35,21 +36,22 @@ def __init__(self,
             cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             step_size, ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+        )
         self.traj_length = L
 
     @staticmethod
-    def get_grad(func, inp):
+    def get_grad(func: Callable[[torch.Tensor], torch.Tensor],
+                 inp: torch.Tensor) -> torch.Tensor:
         """get the gradient of the pdf using autograd
 
         Args:
-            func (callable): function to compute the pdf
-            inp (torch.tensor): input of the function
+            func: function to compute the pdf
+            inp: input of the function
 
         Returns:
-            torch.tensor: gradients of the wavefunction
+            gradient of the wavefunction
         """
         with torch.enable_grad():
             if inp.grad is not None:
@@ -63,7 +65,7 @@ def get_grad(func, inp):
         return inp.grad
 
     @staticmethod
-    def log_func(func):
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]):
         """Compute the negative log of  a function
 
         Args:
@@ -74,16 +76,21 @@ def log_func(func):
         """
         return lambda x: -torch.log(func(x))
 
-    def __call__(self, pdf, pos=None, with_tqdm=True):
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
+                 pos: Optional[torch.Tensor] = None,
+                 with_tqdm: bool = True) -> torch.Tensor:
         """Generate walkers following HMC
 
-        Arguments:
-            pdf {callable} -- density to sample
-            pos (torch.tensor): precalculated position to start with
+        Generates a series of walkers following the HMC algorithm
+
+        Args:
+            pdf (callable): density to sample
+            pos (torch.tensor, optional): precalculated position to start with.
+                                          Defaults to None.
             with_tqdm (bool, optional): use tqdm progress bar. Defaults to True.
 
         Returns:
-            torch.tensor -- sampling points
+            torch.tensor: sampling points
         """
 
         if self.ntherm < 0:
@@ -99,16 +106,21 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
         rate = 0
         idecor = 0
 
-        rng = tqdm(range(self.nstep),
-                   desc='INFO:QMCTorch|  Sampling',
-                   disable=not with_tqdm)
+        rng = tqdm(
+            range(self.nstep),
+            desc="INFO:QMCTorch|  Sampling",
+            disable=not with_tqdm,
+        )
 
         for istep in rng:
-
             # move the walkers
             self.walkers.pos, _r = self._step(
-                logpdf, self.get_grad, self.step_size, self.traj_length,
-                self.walkers.pos)
+                logpdf,
+                self.get_grad,
+                self.step_size,
+                self.traj_length,
+                self.walkers.pos,
+            )
             rate += _r
 
             # store
@@ -118,59 +130,64 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
                 idecor += 1
 
         # print stats
-        log.options(style='percent').debug(
-            "  Acceptance rate %1.3f %%" % (rate / self.nstep * 100))
+        log.options(style="percent").debug(
+            "  Acceptance rate %1.3f %%" % (rate / self.nstep * 100)
+        )
         return torch.cat(pos).requires_grad_()
 
     @staticmethod
-    def _step(U, get_grad, epsilon, L, q_init):
+    def _step(U: Callable[[torch.Tensor], torch.Tensor], 
+              get_grad: Callable[[Callable[[torch.Tensor], torch.Tensor], torch.Tensor], torch.Tensor], 
+              epsilon: float, 
+              L: int, 
+              q_init: torch.Tensor) -> Tuple[torch.Tensor, float]:
         """Take one step of the sampler
 
         Args:
-            U (callable): the target pdf
-            get_grad (callable) : get the value of the target dist gradient
-            epsilon (float) : step size
-            L (int) : number of steps in the traj
-            q_init (torch.Tensor) : initial positon of the walkers
+            U (Callable[[torch.Tensor], torch.Tensor]): The target pdf
+            get_grad (Callable[[Callable[[torch.Tensor], torch.Tensor], torch.Tensor], torch.Tensor]): Function to get the gradient of the target distribution
+            epsilon (float): Step size
+            L (int): Number of steps in the trajectory
+            q_init (torch.Tensor): Initial position of the walkers
 
         Returns:
-            torch.tensor, float:
+            Tuple[torch.Tensor, float]: Updated positions and acceptance rate
         """
 
         q = q_init.clone()
 
-        # init the momentum
+        # Initialize the momentum
         p = torch.randn(q.shape)
 
-        # initial energy terms
-        E_init = U(q) + 0.5 * (p*p).sum(1)
+        # Initial energy terms
+        E_init = U(q) + 0.5 * (p * p).sum(1)
 
-        # half step in momentum space
+        # Half step in momentum space
         p -= 0.5 * epsilon * get_grad(U, q)
 
-        # full steps in q and p space
-        for iL in range(L - 1):
+        # Full steps in q and p space
+        for _ in range(L - 1):
             q += epsilon * p
             p -= epsilon * get_grad(U, q)
 
-        # last full step in pos space
+        # Last full step in position space
         q += epsilon * p
 
-        # half step in momentum space
+        # Half step in momentum space
         p -= 0.5 * epsilon * get_grad(U, q)
 
-        # negate momentum
+        # Negate momentum
         p = -p
 
-        # current energy term
-        E_new = U(q) + 0.5 * (p*p).sum(1)
+        # Current energy term
+        E_new = U(q) + 0.5 * (p * p).sum(1)
 
-        # metropolis accept/reject
+        # Metropolis accept/reject
         eps = torch.rand(E_new.shape)
-        rejected = (torch.exp(E_init - E_new) < eps)
+        rejected = torch.exp(E_init - E_new) < eps
         q[rejected] = q_init[rejected]
 
-        # compute the accept rate
+        # Compute the acceptance rate
         rate = 1 - rejected.sum().float() / rejected.shape[0]
 
         return q, rate
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 51785e5a..b99faeea 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,18 +8,21 @@
 
 
 class Metropolis(SamplerBase):
-
-    def __init__(self,
-                 nwalkers: int = 100,
-                 nstep: int = 1000,
-                 step_size: float = 0.2,
-                 ntherm: int = -1,
-                 ndecor: int = 1,
-                 nelec: int = 1,
-                 ndim: int = 3,
-                 init: Dict = {'min': -5, 'max': 5},
-                 move: Dict = {'type': 'all-elec', 'proba': 'normal'},
-                 cuda: bool = False):
+    def __init__(  # pylint: disable=dangerous-default-value
+        self,
+        nwalkers: int = 100,
+        nstep: int = 1000,
+        step_size: float = 0.2,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Dict = {"min": -5, "max": 5},
+        move: Dict = {"type": "all-elec", "proba": "normal"},
+        logspace: bool = False,
+        symmetry = None,
+        cuda: bool = False,
+    ) -> None:
         """Metropolis Hasting generator
 
         Args:
@@ -50,21 +53,41 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             step_size, ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
+        self.logspace = logspace
         self.configure_move(move)
         self.log_data()
+        if symmetry is None:
+            self.symmetry = lambda x: x
+        else:
+            self.symmetry = symmetry
 
-    def log_data(self):
+    def log_data(self) -> None:
         """log data about the sampler."""
-        log.info('  Move type           : {0}', self.movedict['type'])
-        log.info(
-            '  Move proba          : {0}', self.movedict['proba'])
+        log.info("  Move type           : {0}", self.movedict["type"])
+        log.info("  Move proba          : {0}", self.movedict["proba"])
+
+    @staticmethod
+    def log_func(func):
+        """Compute the negative log of  a function
+
+        Args:
+            func (callable): input function
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+        Returns:
+            callable: negative log of the function
+        """
+        return lambda x: torch.log(func(x))
+
+    def __call__(
+        self,
+        pdf: Callable,
+        pos: Union[None, torch.Tensor] = None,
+        with_tqdm: bool = True,
+    ) -> torch.Tensor:
         """Generate a series of point using MC sampling
 
         Args:
@@ -79,69 +102,83 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
 
         _type_ = torch.get_default_dtype()
         if _type_ == torch.float32:
-            eps = 1E-7
+            eps = 1e-7
         elif _type_ == torch.float64:
-            eps = 1E-16
+            eps = 1e-16
 
         if self.ntherm >= self.nstep:
-            raise ValueError('Thermalisation longer than trajectory')
+            raise ValueError("Thermalisation longer than trajectory")
 
         with torch.no_grad():
-
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
+            # init the walkers
             self.walkers.initialize(pos=pos)
-            fx = pdf(self.walkers.pos)
+
+
+            if self.logspace:
+                fx = self.log_func(pdf)(self.walkers.pos)
+            else:
+                fx = pdf(self.walkers.pos)
 
             fx[fx == 0] = eps
             pos, rate, idecor = [], 0, 0
 
-            rng = tqdm(range(self.nstep),
-                       desc='INFO:QMCTorch|  Sampling',
-                       disable=not with_tqdm)
+            rng = tqdm(
+                range(self.nstep),
+                desc="INFO:QMCTorch|  Sampling",
+                disable=not with_tqdm,
+            )
             tstart = time()
 
             for istep in rng:
-
                 for id_elec in self.fixed_id_elec_list:
-
+                    
                     # new positions
                     Xn = self.move(pdf, id_elec)
 
-                    # new function
-                    fxn = pdf(Xn)
-                    fxn[fxn == 0.] = eps
-                    df = fxn / fx
+                    if self.logspace:
+                        fxn = self.log_func(pdf)(Xn)
+                        df = fxn - fx
+
+                    else:
+                        # new function
+                        fxn = pdf(Xn)
+                        fxn[fxn == 0.0] = eps
+                        df = fxn / fx
 
                     # accept the moves
                     index = self._accept(df)
 
                     # acceptance rate
-                    rate += index.byte().sum().float().to('cpu') / \
-                        (self.nwalkers * self._move_per_iter)
+                    rate += index.byte().sum().float().to("cpu") / (
+                        self.walkers.nwalkers * self._move_per_iter
+                    )
 
                     # update position/function value
                     self.walkers.pos[index, :] = Xn[index, :]
                     fx[index] = fxn[index]
                     fx[fx == 0] = eps
 
-                if (istep >= self.ntherm):
-                    if (idecor % self.ndecor == 0):
-                        pos.append(self.walkers.pos.to('cpu').clone())
+                if istep >= self.ntherm:
+                    if idecor % self.ndecor == 0:
+                        pos.append(self.walkers.pos.to("cpu").clone())
                     idecor += 1
 
             if with_tqdm:
                 log.info(
-                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100))
-                log.info(
-                    "   Timing statistics   : {:1.2f} steps/sec.", self.nstep/(time()-tstart))
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100)
+                )
                 log.info(
-                    "   Total Time          : {:1.2f} sec.", (time()-tstart))
+                    "   Timing statistics   : {:1.2f} steps/sec.",
+                    self.nstep / (time() - tstart),
+                )
+                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
 
-        return torch.cat(pos).requires_grad_()
+        return self.symmetry(torch.cat(pos)).requires_grad_()
 
-    def configure_move(self, move: Dict):
+    def configure_move(self, move: Dict) -> None:
         """Configure the electron moves
 
         Args:
@@ -160,28 +197,30 @@ def configure_move(self, move: Dict):
 
         self.movedict = move
 
-        if 'type' not in self.movedict.keys():
-            print('Metroplis : Set 1 electron move by default')
-            self.movedict['type'] = 'one-elec'
+        if "type" not in self.movedict.keys():
+            print("Metroplis : Set 1 electron move by default")
+            self.movedict["type"] = "one-elec"
 
-        if 'proba' not in self.movedict.keys():
-            print('Metroplis : Set uniform trial move probability')
-            self.movedict['proba'] = 'uniform'
+        if "proba" not in self.movedict.keys():
+            print("Metroplis : Set uniform trial move probability")
+            self.movedict["proba"] = "uniform"
 
-        if self.movedict['proba'] == 'normal':
-            _sigma = self.step_size / \
-                (2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.))))
+        if self.movedict["proba"] == "normal":
+            _sigma = self.step_size / (
+                2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.0)))
+            )
             self.multiVariate = MultivariateNormal(
-                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim))
+                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim)
+            )
 
         self._move_per_iter = 1
-        if self.movedict['type'] not in [
-                'one-elec', 'all-elec', 'all-elec-iter']:
+        if self.movedict["type"] not in ["one-elec", "all-elec", "all-elec-iter"]:
             raise ValueError(
                 " 'type' in move should be 'one-elec','all-elec', \
-                  'all-elec-iter'")
+                  'all-elec-iter'"
+            )
 
-        if self.movedict['type'] == 'all-elec-iter':
+        if self.movedict["type"] == "all-elec-iter":
             self.fixed_id_elec_list = range(self.nelec)
             self._move_per_iter = self.nelec
         else:
@@ -197,28 +236,24 @@ def move(self, pdf: Callable, id_elec: int) -> torch.Tensor:
         Returns:
             torch.tensor: new positions of the walkers
         """
-        if self.nelec == 1 or self.movedict['type'] == 'all-elec':
+        if self.nelec == 1 or self.movedict["type"] == "all-elec":
             return self.walkers.pos + self._move(self.nelec)
 
         else:
-
             # clone and reshape data : Nwlaker, Nelec, Ndim
             new_pos = self.walkers.pos.clone()
-            new_pos = new_pos.view(self.nwalkers,
-                                   self.nelec, self.ndim)
+            new_pos = new_pos.view(self.walkers.nwalkers, self.nelec, self.ndim)
 
             # get indexes
             if id_elec is None:
-                index = torch.LongTensor(self.nwalkers).random_(
-                    0, self.nelec)
+                index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
             else:
-                index = torch.LongTensor(self.nwalkers).fill_(id_elec)
+                index = torch.LongTensor(self.walkers.nwalkers).fill_(id_elec)
 
             # change selected data
-            new_pos[range(self.nwalkers), index,
-                    :] += self._move(1)
+            new_pos[range(self.walkers.nwalkers), index, :] += self._move(1)
 
-            return new_pos.view(self.nwalkers, self.nelec * self.ndim)
+            return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
     def _move(self, num_elec: int) -> torch.Tensor:
         """propose a move for the electrons
@@ -229,17 +264,19 @@ def _move(self, num_elec: int) -> torch.Tensor:
         Returns:
             torch.tensor: new positions of the walkers
         """
-        if self.movedict['proba'] == 'uniform':
+        if self.movedict["proba"] == "uniform":
             d = torch.rand(
-                (self.nwalkers, num_elec, self.ndim), device=self.device).view(
-                self.nwalkers, num_elec * self.ndim)
-            return self.step_size * (2. * d - 1.)
+                (self.walkers.nwalkers, num_elec, self.ndim), device=self.device
+            ).view(self.walkers.nwalkers, num_elec * self.ndim)
+            out = self.step_size * (2.0 * d - 1.0)
 
-        elif self.movedict['proba'] == 'normal':
+        elif self.movedict["proba"] == "normal":
             displacement = self.multiVariate.sample(
-                (self.nwalkers, num_elec)).to(self.device)
-            return displacement.view(
-                self.nwalkers, num_elec * self.ndim)
+                (self.walkers.nwalkers, num_elec)
+            ).to(self.device)
+            out = displacement.view(self.walkers.nwalkers, num_elec * self.ndim)
+
+        return out
 
     def _accept(self, proba: torch.Tensor) -> torch.Tensor:
         """accept the move or not
@@ -250,8 +287,14 @@ def _accept(self, proba: torch.Tensor) -> torch.Tensor:
         Returns:
             t0rch.tensor: the indx of the accepted moves
         """
-
-        proba[proba > 1] = 1.0
-        tau = torch.rand_like(proba)
-        index = (proba - tau >= 0).reshape(-1)
-        return index.type(torch.bool)
+        if self.logspace:
+            proba[proba > 0] = 0.0
+            tau = torch.log(torch.rand_like(proba))
+            index = (proba - tau >= 0).reshape(-1)
+            out = index.type(torch.bool)
+        else:
+            proba[proba > 1] = 1.0
+            tau = torch.rand_like(proba)
+            index = (proba - tau >= 0).reshape(-1)
+            out = index.type(torch.bool)
+        return out
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
new file mode 100644
index 00000000..bcb00645
--- /dev/null
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -0,0 +1,230 @@
+from tqdm import tqdm
+import torch
+from torch.distributions import MultivariateNormal
+from time import time
+from typing import Callable, Union, Dict
+from .sampler_base import SamplerBase
+from .. import log
+
+
+class Metropolis(SamplerBase):
+    def __init__(
+        self,
+        nwalkers: int = 100,
+        nstep: int = 1000,
+        step_size: float = 0.2,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Dict = {"min": -5, "max": 5},
+        move: Dict = {"proba": "normal"},
+        logspace: bool = False,
+        cuda: bool = False,
+    ):
+        """Metropolis Hasting generator
+
+        Args:
+            nwalkers (int, optional): Number of walkers. Defaults to 100.
+            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
+            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()
+
+            move (dict, optional): method to move the electrons. default('all-elec','normal') \n
+                                   'type':
+                                        'one-elec': move a single electron per iteration \n
+                                        '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
+                                        'normal': gussian in a sphere \n
+            cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
+
+
+        Examples::
+            >>> mol = Molecule('h2.xyz')
+            >>> wf = SlaterJastrow(mol)
+            >>> sampler = Metropolis(nwalkers=100, nelec=wf.nelec)
+            >>> pos = sampler(wf.pdf)
+        """
+
+        SamplerBase.__init__(
+            self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+        )
+
+        self.logspace = logspace
+        self.movedict = move
+
+        if self.movedict["proba"] == "normal":
+            _sigma = self.step_size / (
+                2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.0)))
+            )
+            self.multiVariate = MultivariateNormal(
+                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim)
+            )
+
+        self.log_data()
+
+    def log_data(self) -> None:
+        """log data about the sampler."""
+        log.info("  Move type           : {0}", "all-elec")
+        log.info("  Move proba          : {0}", self.movedict["proba"])
+
+    @staticmethod
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
+        """Compute the log of a function
+
+        Args:
+            func (Callable[[torch.Tensor], torch.Tensor]): input function
+
+        Returns:
+            Callable[[torch.Tensor], torch.Tensor]: log of the function
+        """
+        return lambda x: torch.log(func(x))
+
+    def __call__(
+        self,
+        pdf: Callable,
+        pos: Union[None, torch.Tensor] = None,
+        with_tqdm: bool = True,
+    ) -> torch.Tensor:
+        """Generate a series of point using MC sampling
+
+        Args:
+            pdf (callable): probability distribution function to be sampled
+            pos (torch.tensor, optional): position to start with.
+                                          Defaults to None.
+            with_tqdm (bool, optional): use tqdm progress bar. Defaults to True.
+
+        Returns:
+            torch.tensor: positions of the walkers
+        """
+
+        # _type_ = torch.get_default_dtype()
+        # if _type_ == torch.float32:
+        #     eps = 1E-7
+        # elif _type_ == torch.float64:
+        #     eps = 1E-16
+
+        if self.ntherm >= self.nstep:
+            raise ValueError("Thermalisation longer than trajectory")
+
+        with torch.no_grad():
+            if self.ntherm < 0:
+                self.ntherm = self.nstep + self.ntherm
+
+            self.walkers.initialize(pos=pos)
+            if self.logspace:
+                fx = self.log_func(pdf)(self.walkers.pos)
+            else:
+                fx = pdf(self.walkers.pos)
+
+            # fx[fx == 0] = eps
+            pos, rate, idecor = [], 0, 0
+
+            rng = tqdm(
+                range(self.nstep),
+                desc="INFO:QMCTorch|  Sampling",
+                disable=not with_tqdm,
+            )
+            tstart = time()
+
+            for istep in rng:
+                # new positions
+                Xn = self.move(pdf)
+
+                if self.logspace:
+                    fxn = self.log_func(pdf)(Xn)
+                    df = fxn - fx
+
+                else:
+                    # new function
+                    fxn = pdf(Xn)
+                    # fxn[fxn == 0.] = eps
+                    df = fxn / fx
+
+                # accept the moves
+                index = self._accept(df)
+
+                # acceptance rate
+                rate += index.byte().sum().float().to("cpu") / (self.walkers.nwalkers)
+
+                # update position/function value
+                self.walkers.pos[index, :] = Xn[index, :]
+                fx[index] = fxn[index]
+                # fx[fx == 0] = eps
+
+                if istep >= self.ntherm:
+                    if idecor % self.ndecor == 0:
+                        pos.append(self.walkers.pos.to("cpu").clone())
+                    idecor += 1
+
+            if with_tqdm:
+                log.info(
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100)
+                )
+                log.info(
+                    "   Timing statistics   : {:1.2f} steps/sec.",
+                    self.nstep / (time() - tstart),
+                )
+                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
+
+        return torch.cat(pos).requires_grad_()
+
+    def move(self, pdf: Callable) -> torch.Tensor:
+        """Move electron one at a time in a vectorized way.
+
+        Args:
+            pdf (callable): function to sample
+
+        Returns:
+            torch.tensor: new positions of the walkers
+        """
+
+        return self.walkers.pos + self._move(self.nelec)
+
+    def _move(self, num_elec: int) -> torch.Tensor:
+        """propose a move for the electrons
+
+        Args:
+            num_elec (int): number of electrons to move
+
+        Returns:
+            torch.tensor: new positions of the walkers
+        """
+        if self.movedict["proba"] == "uniform":
+            d = torch.rand(
+                (self.walkers.nwalkers, num_elec * self.ndim), device=self.device
+            )
+            return self.step_size * (2.0 * d - 1.0)
+
+        elif self.movedict["proba"] == "normal":
+            displacement = self.multiVariate.sample(
+                (self.walkers.nwalkers, num_elec)
+            ).to(self.device)
+            return displacement.view(self.walkers.nwalkers, num_elec * self.ndim)
+
+    def _accept(self, proba: torch.Tensor) -> torch.Tensor:
+        """accept the move or not
+
+        Args:
+            proba (torch.tensor): probability of each move
+
+        Returns:
+            t0rch.tensor: the indx of the accepted moves
+        """
+        if self.logspace:
+            proba[proba > 0] = 0.0
+            tau = torch.log(torch.rand_like(proba))
+            index = (proba - tau >= 0).reshape(-1)
+            return index.type(torch.bool)
+        else:
+            proba[proba > 1] = 1.0
+            tau = torch.rand_like(proba)
+            index = (proba - tau >= 0).reshape(-1)
+            return index.type(torch.bool)
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
new file mode 100644
index 00000000..cc251d55
--- /dev/null
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -0,0 +1,173 @@
+from tqdm import tqdm
+import torch
+from time import time
+from typing import Callable, Union, Dict
+from .sampler_base import SamplerBase
+from .. import log
+
+from .proposal_kernels import ConstantVarianceKernel, BaseProposalKernel
+from .state_dependent_normal_proposal import StateDependentNormalProposal
+
+
+class MetropolisHasting(SamplerBase):
+    def __init__(
+        self,
+        kernel: BaseProposalKernel = ConstantVarianceKernel(0.2),
+        nwalkers: int = 100,
+        nstep: int = 1000,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Dict = {"min": -5, "max": 5},
+        logspace: bool = False,
+        cuda: bool = False,
+    ) -> None:
+        """Metropolis Hasting generator
+
+        Args:
+            kernel (BaseProposalKernel, optional): proposal kernel. Defaults to ConstantVarianceKernel(0.2).
+            nwalkers (int, optional): Number of walkers. Defaults to 100.
+            nstep (int, optional): Number of steps. Defaults to 1000.
+            ntherm (int, optional): number of mc step to thermalize. Defaults to -1, i.e. keep ponly last position
+            ndecor (int, optional): number of mc step for decorelation. Defauts to 1.
+            nelec (int, optional): total number of electrons. Defaults 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()
+            logspace (bool, optional):  Defaults to False.
+            cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
+
+        Returns:
+            None
+
+        Examples::
+            >>> mol = Molecule('h2.xyz')
+            >>> wf = SlaterJastrow(mol)
+            >>> sampler = Metropolis(nwalkers=100, nelec=wf.nelec)
+            >>> pos = sampler(wf.pdf)
+        """
+
+        SamplerBase.__init__(
+            self, nwalkers, nstep, 0.0, ntherm, ndecor, nelec, ndim, init, cuda
+        )
+
+        self.proposal = StateDependentNormalProposal(kernel, nelec, ndim, self.device)
+
+        self.proposal.kernel.nelec = nelec
+        self.proposal.kernel.ndim = ndim
+
+        self.logspace = logspace
+
+        self.log_data()
+
+    def log_data(self) -> None:
+        """log data about the sampler."""
+        # log.info('  Move type           : {0}', 'all-elec')
+
+    @staticmethod
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
+        """Compute the negative log of  a function
+
+        Args:
+            func: input function
+
+        Returns:
+            callable: negative log of the function
+        """
+        return lambda x: torch.log(func(x))
+
+    def __call__(
+        self,
+        pdf: Callable[[torch.Tensor], torch.Tensor],
+        pos: Union[None, torch.Tensor] = None,
+        with_tqdm: bool = True,
+    ) -> torch.Tensor:
+        """Generate a series of point using MC sampling
+
+        Args:
+            pdf (callable): probability distribution function to be sampled
+            pos (torch.tensor, optional): position to start with.
+                                          Defaults to None.
+            with_tqdm (bool, optional): use tqdm progress bar. Defaults to True.
+
+        Returns:
+            torch.tensor: positions of the walkers
+        """
+
+        if self.ntherm >= self.nstep:
+            raise ValueError("Thermalisation longer than trajectory")
+
+        with torch.no_grad():
+            if self.ntherm < 0:
+                self.ntherm = self.nstep + self.ntherm
+
+            self.walkers.initialize(pos=pos)
+            fx = pdf(self.walkers.pos)
+
+            pos, rate, idecor = [], 0, 0
+
+            rng = tqdm(
+                range(self.nstep),
+                desc="INFO:QMCTorch|  Sampling",
+                disable=not with_tqdm,
+            )
+            tstart = time()
+
+            for istep in rng:
+                # new positions
+                Xn = self.walkers.pos + self.proposal(self.walkers.pos)
+
+                # new function
+                fxn = pdf(Xn)
+
+                # proba ratio
+                prob_ratio = fxn / fx
+
+                # get transition ratio
+                trans_ratio = self.proposal.get_transition_ratio(self.walkers.pos, Xn)
+
+                # get the proba
+                df = prob_ratio * trans_ratio
+
+                # accept the moves
+                index = self.accept_reject(df)
+
+                # acceptance rate
+                rate += index.byte().sum().float().to("cpu") / (self.walkers.nwalkers)
+
+                # update position/function value
+                self.walkers.pos[index, :] = Xn[index, :]
+                fx[index] = fxn[index]
+
+                if istep >= self.ntherm:
+                    if idecor % self.ndecor == 0:
+                        pos.append(self.walkers.pos.to("cpu").clone())
+                    idecor += 1
+
+            if with_tqdm:
+                log.info(
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100)
+                )
+                log.info(
+                    "   Timing statistics   : {:1.2f} steps/sec.",
+                    self.nstep / (time() - tstart),
+                )
+                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
+
+        return torch.cat(pos).requires_grad_()
+
+    def accept_reject(self, proba: torch.Tensor) -> torch.Tensor:
+        """accept the move or not
+
+        Args:
+            proba (torch.tensor): probability of each move
+
+        Returns:
+            torch.tensor: the indx of the accepted moves
+        """
+
+        proba[proba > 1] = 1.0
+        tau = torch.rand_like(proba)
+        index = (proba - tau >= 0).reshape(-1)
+        return index.type(torch.bool)
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
new file mode 100644
index 00000000..bd8cfa0f
--- /dev/null
+++ b/qmctorch/sampler/pints_sampler.py
@@ -0,0 +1,173 @@
+import torch
+import pints
+import numpy
+from typing import Callable, Union, Dict, Tuple
+from .sampler_base import SamplerBase
+
+
+class torch_model(pints.LogPDF):
+    def __init__(self, pdf: Callable[[torch.Tensor], torch.Tensor], ndim: int) -> None:
+        """Ancillary class that wraps the wave function in a PINTS class
+
+        Args:
+            pdf: wf.pdf function
+            ndim: number of dimensions
+        """
+        self.pdf = pdf 
+        self.ndim = ndim
+
+    def __call__(self, x: numpy.ndarray) -> numpy.ndarray:
+        """Evaluate the log pdf of the wave function at points x
+
+        Args:
+            x: positions of the walkers (numpy array)
+
+        Returns:
+            values of the log pdf at those points (numpy array)
+        """
+        x = torch.as_tensor(x).view(1, -1)
+        return torch.log(self.pdf(x)).cpu().detach().numpy()
+
+    def evaluateS1(self, x: numpy.ndarray) -> Tuple[numpy.ndarray, numpy.ndarray]:
+        """Evaluate the log pdf and the gradients of the log pdf at points x
+
+        Args:
+            x (numpy.ndarray): positions of the walkers
+
+        Returns:
+            tuple:
+                log_pdf (numpy.ndarray): values of the log pdf
+                grad_log_pdf (numpy.ndarray): gradients of the log pdf
+        """
+
+        x = torch.as_tensor(x).view(1, -1)
+        pdf = self.pdf(x)
+        log_pdf = torch.log(pdf)
+        x.requires_grad = True
+        grad_log_pdf = 1.0 / pdf * self.pdf(x, return_grad=True)
+        return (log_pdf.cpu().detach().numpy(), grad_log_pdf.cpu().detach().numpy())
+
+    def n_parameters(self) -> int:
+        """Returns the number of dimensions."""
+        return self.ndim
+
+
+class PintsSampler(SamplerBase):
+    def __init__(
+        self,
+        nwalkers: int = 100,
+        method=pints.MetropolisRandomWalkMCMC,
+        method_requires_grad=False,
+        nstep: int = 1000,
+        ntherm: int = -1,
+        ndecor: int = 1,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Dict = {"min": -5, "max": 5},
+        cuda: bool = False,
+        log_to_screen=False,
+        message_interval=20,
+    ):
+        """Interface to the PINTS Sampler generator
+
+        Args:
+            nwalkers (int, optional): Number of walkers. Defaults to 100.
+            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
+            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()
+
+            move (dict, optional): method to move the electrons. default('all-elec','normal') \n
+                                   'type':
+                                        'one-elec': move a single electron per iteration \n
+                                        '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
+                                        'normal': gussian in a sphere \n
+            cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
+
+
+        Examples::
+            >>> mol = Molecule('h2.xyz')
+            >>> wf = SlaterJastrow(mol)
+            >>> sampler = Metropolis(nwalkers=100, nelec=wf.nelec)
+            >>> pos = sampler(wf.pdf)
+        """
+
+        SamplerBase.__init__(
+            self, nwalkers, nstep, None, ntherm, ndecor, nelec, ndim, init, cuda
+        )
+
+        self.method = method
+        self.method_requires_grad = method_requires_grad
+        self.log_to_screen = log_to_screen
+        self.message_interval = message_interval
+        self.log_data()
+
+    def log_data(self):
+        """log data about the sampler."""
+        # log.info(
+        #     '  Sampler             : {0}', self.method.name(None))
+
+    @staticmethod
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
+        """Compute the negative log of a function
+
+        Args:
+            func (Callable[[torch.Tensor], torch.Tensor]): input function
+
+        Returns:
+            Callable[[torch.Tensor], torch.Tensor]: negative log of the function
+        """
+        return lambda x: torch.log(func(torch.as_tensor(x)))
+
+    def __call__(
+        self,
+        pdf: Callable,
+        pos: Union[None, torch.Tensor] = None,
+        with_tqdm: bool = True,
+    ) -> torch.Tensor:
+        """Generate a series of point using MC sampling
+
+        Args:
+            pdf (callable): probability distribution function to be sampled
+            pos (torch.tensor, optional): position to start with.
+                                          Defaults to None.
+            with_tqdm (bool, optional): use tqdm progress bar. Defaults to True.
+
+        Returns:
+            torch.tensor: positions of the walkers
+        """
+
+        if self.ntherm >= self.nstep:
+            raise ValueError("Thermalisation longer than trajectory")
+
+        grad_method = torch.no_grad()
+        if self.method_requires_grad:
+            grad_method = torch.enable_grad()
+
+        with grad_method:
+            if self.ntherm < 0:
+                self.ntherm = self.nstep + self.ntherm
+
+            self.walkers.initialize(pos=pos)
+            log_pdf = torch_model(pdf, self.walkers.pos.shape[1])
+
+            mcmc = pints.MCMCController(
+                log_pdf,
+                self.walkers.nwalkers,
+                self.walkers.pos.cpu(),
+                method=self.method,
+            )
+            mcmc.set_max_iterations(self.nstep)
+            mcmc._log_to_screen = self.log_to_screen
+            mcmc._message_interval = self.message_interval
+            chains = mcmc.run()
+
+        chains = chains[:, self.ntherm :: self.ndecor, :]
+        chains = chains.reshape(-1, self.nelec * self.ndim)
+        return torch.as_tensor(chains).requires_grad_()
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
new file mode 100644
index 00000000..508a9290
--- /dev/null
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -0,0 +1,58 @@
+import torch
+
+
+class BaseProposalKernel(object):
+    def __call__(self, x):
+        raise NotImplementedError   
+
+class DensityVarianceKernel(BaseProposalKernel):
+    def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
+        self.atomic_pos = atomic_pos.unsqueeze(0).unsqueeze(1)
+        self.sigma = sigma
+        self.scale_factor = scale_factor
+        self.nelec = None
+        self.ndim = None
+
+    def __call__(self, x):
+        d = self.get_estimate_density(x)
+        out = self.sigma * (1.0 - d).sum(-1)
+        return out.unsqueeze(-1)
+
+    def get_atomic_distance(self, pos):
+        nwalkers = pos.shape[0]
+        pos = pos.view(nwalkers, self.nelec, self.ndim)
+        dist = pos.unsqueeze(-2) - self.atomic_pos
+        return dist.norm(dim=-1)
+
+    def get_estimate_density(self, pos):
+        d = self.get_atomic_distance(pos)
+        d = torch.exp(-self.scale_factor * d**2)
+        return d
+
+
+class CenterVarianceKernel(BaseProposalKernel):
+    def __init__(self, sigma=1.0, scale_factor=1.0):
+        self.sigma = sigma
+        self.scale_factor = scale_factor
+        self.nelec = None
+        self.ndim = None
+
+    def __call__(self, x):
+        d = self.get_estimate_density(x)
+        out = self.sigma * (1.0 - d)
+        return out.unsqueeze(-1)
+
+    def get_estimate_density(self, pos):
+        nwalkers = pos.shape[0]
+        pos = pos.view(nwalkers, self.nelec, self.ndim)
+        d = pos.norm(dim=-1)
+        d = torch.exp(-self.scale_factor * d**2)
+        return d
+
+
+class ConstantVarianceKernel(BaseProposalKernel):
+    def __init__(self, sigma=0.2):
+        self.sigma = sigma
+
+    def __call__(self, x):
+        return self.sigma
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index 9dbaf420..9f037ed2 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -1,14 +1,22 @@
 import torch
-
+from typing import Dict, Callable
 from .. import log
 from .walkers import Walkers
 
 
 class SamplerBase:
-
-    def __init__(self, nwalkers, nstep, step_size,
-                 ntherm, ndecor, nelec, ndim, init,
-                 cuda):
+    def __init__(
+        self,
+        nwalkers: int,
+        nstep: int,
+        step_size: float,
+        ntherm: int,
+        ndecor: int,
+        nelec: int,
+        ndim: int,
+        init: Dict,
+        cuda: bool,
+    ) -> None:
         """Base class for the sampler
 
         Args:
@@ -16,14 +24,14 @@ def __init__(self, nwalkers, nstep, step_size,
             nstep (int): number of MC steps
             step_size (float): size of the steps in bohr
             ntherm (int): number of MC steps to thermalize
-            ndecor (int): unmber of MC steps to decorellate
+            ndecor (int): number of MC steps to decorellate
             nelec (int): number of electrons in the system
             ndim (int): number of cartesian dimension
             init (dict): method to initialize the walkers
-            cuda ([type]): [description]
+            cuda (bool): turn CUDA ON/OFF
         """
 
-        self.nwalkers = nwalkers
+        # self.nwalkers = nwalkers
         self.nelec = nelec
         self.ndim = ndim
         self.nstep = nstep
@@ -32,32 +40,50 @@ def __init__(self, nwalkers, nstep, step_size,
         self.ndecor = ndecor
         self.cuda = cuda
         if cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         else:
-            self.device = torch.device('cpu')
+            self.device = torch.device("cpu")
 
         self.walkers = Walkers(
-            nwalkers=nwalkers, nelec=nelec, ndim=ndim, init=init, cuda=cuda)
+            nwalkers=nwalkers,
+            nelec=nelec,
+            ndim=ndim,
+            init=init,
+            cuda=cuda,
+        )
 
-        log.info('')
-        log.info(' Monte-Carlo Sampler')
-        log.info('  Number of walkers   : {0}', self.nwalkers)
-        log.info('  Number of steps     : {0}', self.nstep)
-        log.info('  Step size           : {0}', self.step_size)
-        log.info('  Thermalization steps: {0}', self.ntherm)
-        log.info('  Decorelation steps  : {0}', self.ndecor)
-        log.info('  Walkers init pos    : {0}', init['method'])
+        log.info("")
+        log.info(" Monte-Carlo Sampler")
+        log.info("  Number of walkers   : {0}", self.walkers.nwalkers)
+        log.info("  Number of steps     : {0}", self.nstep)
+        log.info("  Step size           : {0}", self.step_size)
+        log.info("  Thermalization steps: {0}", self.ntherm)
+        log.info("  Decorelation steps  : {0}", self.ndecor)
+        log.info("  Walkers init pos    : {0}", init["method"])
+
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor], *args, **kwargs) -> torch.Tensor:
+        """
+        Evaluate the sampling algorithm.
 
-    def __call__(self, pdf, *args, **kwargs):
-        raise NotImplementedError(
-            "Sampler must have a __call__ method")
+        Args:
+            pdf (Callable[[torch.Tensor], torch.Tensor]): the function to sample
+            *args: additional positional arguments
+            **kwargs: additional keyword arguments
+
+        Returns:
+            torch.Tensor: the samples
+        """
+        raise NotImplementedError("Sampler must have a __call__ method")
 
-    def __repr__(self):
-        return self.__class__.__name__ + ' sampler with  %d walkers' % self.nwalkers
+    def __repr__(self) -> str:
+        return (
+            self.__class__.__name__
+            + " sampler with  %d walkers" % self.walkers.nwalkers
+        )
 
-    def get_sampling_size(self):
+    def get_sampling_size(self) -> int:
         """evaluate the number of sampling point we'll have."""
         if self.ntherm == -1:
-            return self.nwalkers
+            return self.walkers.nwalkers
         else:
-            return self.walkers.nwalkers * int((self.nstep-self.ntherm)/self.ndecor)
+            return self.walkers.nwalkers * int((self.nstep - self.ntherm) / self.ndecor)
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
new file mode 100644
index 00000000..89196d1e
--- /dev/null
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -0,0 +1,70 @@
+import torch
+from typing import Callable
+from torch.distributions import MultivariateNormal
+
+
+class StateDependentNormalProposal(object):
+    def __init__(
+        self,
+        kernel: Callable[[torch.Tensor], torch.Tensor],
+        nelec: int,
+        ndim: int,
+        device: torch.device,
+    ) -> None:
+        """
+        Initialize StateDependentNormalProposal.
+
+        Args:
+            kernel: A callable that takes a tensor of shape (nwalkers, nelec*ndim)
+                and returns a tensor of shape (nwalkers, nelec*ndim).
+            nelec: The number of electrons.
+            ndim: The number of dimensions.
+            device: The device to use for computations.
+        """
+        self.ndim = ndim
+        self.nelec = nelec
+        self.kernel = kernel
+        self.device = device
+        self.multiVariate = MultivariateNormal(
+            torch.zeros(self.ndim), 1.0 * torch.eye(self.ndim)
+        )
+
+    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Compute the proposal distribution
+
+        Args:
+            x: The current position of the walkers, shape (nwalkers, nelec*ndim)
+
+        Returns:
+            The displacement, shape (nwalkers, nelec*ndim)
+        """
+        nwalkers = x.shape[0]
+        scale = self.kernel(x)  # shape (nwalkers, nelec*ndim)
+        displacement = self.multiVariate.sample((nwalkers, self.nelec))  # shape (nwalkers, nelec, ndim)
+        displacement *= scale  # shape (nwalkers, nelec, ndim)
+        return displacement.view(nwalkers, self.nelec * self.ndim)
+
+    def get_transition_ratio(
+        self, x: torch.Tensor, y: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Compute the transition ratio for the Metropolis-Hastings acceptance probability.
+
+        Args:
+            x: The current position of the walkers, shape (nwalkers, nelec*ndim)
+            y: The proposed position of the walkers, shape (nwalkers, nelec*ndim)
+
+        Returns:
+            The transition ratio, shape (nwalkers,)
+        """
+        sigmax = self.kernel(x)
+        sigmay = self.kernel(y)
+
+        rdist = (x - y).view(-1, self.nelec, self.ndim).norm(dim=-1).unsqueeze(-1)
+
+        prefac = (sigmax / sigmay) ** (self.ndim / 2)
+        tratio = torch.exp(-0.5 * rdist**2 * (1.0 / sigmay - 1.0 / sigmax))
+        tratio *= prefac
+
+        return tratio.squeeze().prod(-1)
diff --git a/qmctorch/sampler/symmetry.py b/qmctorch/sampler/symmetry.py
new file mode 100644
index 00000000..b69ee6c1
--- /dev/null
+++ b/qmctorch/sampler/symmetry.py
@@ -0,0 +1,164 @@
+
+from abc import ABC
+import torch 
+
+
+def planar_symmetry(pos: torch.tensor, plane: str, nelec: int, ndim: int, inplace=False):
+    """
+    Apply a planar symmetry operation to a set of positions.
+
+    Args:
+        pos (torch.tensor): The input tensor representing positions, 
+            expected shape is (N, ndim * nelec).
+        plane (str): The plane of symmetry, can be 'xy', 'xz', or 'yz'.
+        nelec (int): Number of electrons (or particles).
+        ndim (int): Number of dimensions per electron.
+        inplace (bool, optional): If True, modify the input tensor in place. 
+            Defaults to False.
+
+    Returns:
+        torch.tensor: A tensor with the planar symmetry operation applied.
+    """
+    if  inplace:
+        out = pos
+    else:
+        out = torch.clone(pos)
+
+    if not isinstance(plane, list):
+        plane = [plane]
+    
+    for p in plane:
+        offset = {'xy':2, 'xz':1, 'yz':0}[p]
+        out[:, [ndim*ielec + offset for ielec in range(nelec)]] *= -1.0
+    return out
+
+class BaseSymmetry(ABC):
+    def __init__(self, label: str):
+        self.label = label
+        self.nelec = None
+        self.ndim = 3
+
+    def __call__(self, pos: torch.tensor) -> torch.tensor:
+        raise NotImplementedError
+    
+
+class C1(BaseSymmetry):
+    def __init__(self):
+        """
+        Initialize the C1 symmetry (No symmetry)
+
+        Parameters
+        ----------
+        label : str
+            The name of the symmetry.
+
+        """
+        super().__init__('C1')    
+    
+    def __call__(self, pos: torch.tensor) -> torch.tensor:
+        """
+        Apply the symmetry to a given position.
+
+        Parameters
+        ----------
+        pos : torch.tensor
+            The positions of the walkers. The shape of the tensor is (Nbatch, Nelec x Ndim).
+
+        Returns
+        -------
+        torch.tensor
+            The positions with the symmetry applied.
+        """
+        return pos
+    
+class Cinfv(BaseSymmetry):
+    def __init__(self, axis: str):
+        """
+        Initialize the Cinfv symmetry (Infinite axis of symmetry).
+
+        Parameters
+        ----------
+        label : str
+            The name of the symmetry.
+        axis : str
+            The axis of symmetry. Can be 'x', 'y', or 'z'.
+
+        """
+        super().__init__('Cinfv')   
+        if axis not in ['x', 'y', 'z']:
+            raise ValueError(f"Axis {axis} is not valid. Must be 'x', 'y', or 'z'.")
+        self.axis = axis
+        self.symmetry_planes = {'x':['xy','xz'],
+                                'y':['xy','yz'],
+                                'z':['xz','yz']}[self.axis]
+    
+    def __call__(self, pos: torch.tensor) -> torch.tensor:
+        """
+        Apply the symmetry to a given position.
+
+        Parameters
+        ----------
+        pos : torch.tensor
+            The positions of the walkers. The shape of the tensor is (Nbatch, Nelec x Ndim).
+
+        Returns
+        -------
+        torch.tensor
+            The positions with the symmetry applied.
+        """
+        if self.nelec is None:
+            self.nelec = pos.shape[1] // self.ndim
+
+        symmetry_pos = []
+        symmetry_pos.append(pos)
+        for plane in self.symmetry_planes:
+            symmetry_pos.append(planar_symmetry(pos, plane, self.nelec, self.ndim, inplace=False))
+        symmetry_pos.append(planar_symmetry(pos, self.symmetry_planes, self.nelec, self.ndim, inplace=False))
+        return torch.cat(symmetry_pos, dim=0).requires_grad_(pos.requires_grad)
+    
+class Dinfh(BaseSymmetry):
+    def __init__(self, axis: str):
+        """
+        Initialize the Dinfh symmetry (Infinite dihedral symmetry).
+
+        Parameters
+        ----------
+        label : str
+            The name of the symmetry.
+        axis : str
+            The axis of symmetry. Can be 'x', 'y', or 'z'.
+        """
+        
+        super().__init__('Dinfv')
+        if axis not in ['x', 'y', 'z']:
+            raise ValueError(f"Axis {axis} is not valid. Must be 'x', 'y', or 'z'.")
+        self.axis = axis
+        self.symmetry_planes = {'x':['xy','xz'],
+                                'y':['xy','yz'],
+                                'z':['xz','yz']}[self.axis]
+        self.last_symmetry = {'x':'yz', 'y':'xz', 'z':'xy'}[self.axis]
+    
+
+    def __call__(self, pos: torch.tensor) -> torch.tensor:
+        """
+        Apply the symmetry to a given position.
+
+        Parameters
+        ----------
+        pos : torch.tensor
+            The positions of the walkers. The shape of the tensor is (Nbatch, Nelec x Ndim).
+
+        Returns
+        -------
+        torch.tensor
+            The positions with the symmetry applied.
+        """
+        if self.nelec is None:
+            self.nelec = pos.shape[1] // self.ndim
+        symmetry_pos = []
+        symmetry_pos.append(pos)
+        for plane in self.symmetry_planes:
+            symmetry_pos.append(planar_symmetry(pos, plane, self.nelec, self.ndim, inplace=False))
+        symmetry_pos.append(planar_symmetry(pos, self.symmetry_planes, self.nelec, self.ndim, inplace=False))
+        symmetry_pos.append(planar_symmetry(torch.cat(symmetry_pos, dim=0), self.last_symmetry, self.nelec, self.ndim, inplace=False))
+        return torch.cat(symmetry_pos, dim=0).requires_grad_(pos.requires_grad)
\ No newline at end of file
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index 4b88fd12..36656706 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -5,10 +5,15 @@
 from .. import log
 
 
-class Walkers(object):
-
-    def __init__(self, nwalkers: int = 100, nelec: int = 1, ndim: int = 3,
-                 init: Union[Dict, None] = None, cuda: bool = False):
+class Walkers:
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        nwalkers: int = 100,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Union[Dict, None] = None,
+        cuda: bool = False,
+    ) -> None:
         """Creates Walkers for the sampler.
 
         Args:
@@ -29,11 +34,11 @@ def __init__(self, nwalkers: int = 100, nelec: int = 1, ndim: int = 3,
         self.cuda = cuda
 
         if cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         else:
-            self.device = torch.device('cpu')
+            self.device = torch.device("cpu")
 
-    def initialize(self, pos: Union[None, torch.Tensor] = None):
+    def initialize(self, pos: Union[None, torch.Tensor] = None) -> None:
         """Initalize the position of the walkers
 
         Args:
@@ -44,104 +49,101 @@ def initialize(self, pos: Union[None, torch.Tensor] = None):
             ValueError: if the method is not recognized
         """
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
         if pos is not None:
             if len(pos) > self.nwalkers:
-                pos = pos[-self.nwalkers:, :]
+                pos = pos[-self.nwalkers :, :]
             self.pos = pos
 
         else:
             log.debug("  Initialize walkers")
-            if 'center' in self.init_domain.keys():
+            if "center" in self.init_domain.keys():
                 self.pos = self._init_center()
 
-            elif 'min' in self.init_domain.keys():
+            elif "min" in self.init_domain.keys():
                 self.pos = self._init_uniform()
 
-            elif 'mean' in self.init_domain.keys():
+            elif "mean" in self.init_domain.keys():
                 self.pos = self._init_multivar()
 
-            elif 'atom_coords' in self.init_domain.keys():
+            elif "atom_coords" in self.init_domain.keys():
                 self.pos = self._init_atomic()
 
             else:
-                raise ValueError('Init walkers not recognized')
+                raise ValueError("Init walkers not recognized")
 
-    def _init_center(self):
+    def _init_center(self) -> torch.Tensor:
         """Initialize the walkers at the center of the molecule
 
         Returns:
-            torch.tensor: positions of the walkers
+            torch.tensor: positions of the walkers, shape (nwalkers, nelec * ndim)
         """
-        eps = 1E-3
-        pos = -eps + 2 * eps * \
-            torch.rand(self.nwalkers, self.nelec * self.ndim)
-        return pos.type(
-            torch.get_default_dtype()).to(
-            device=self.device)
-
-    def _init_uniform(self):
+        eps = 1e-3
+        pos = -eps + 2 * eps * torch.rand(self.nwalkers, self.nelec * self.ndim)
+        return pos.type(torch.get_default_dtype()).to(device=self.device)
+
+    def _init_uniform(self) -> torch.Tensor:
         """Initialize the walkers in a box covering the molecule
 
         Returns:
-            torch.tensor: positions of the walkers
+            torch.tensor: positions of the walkers, shape (nwalkers, nelec * ndim)
         """
         pos = torch.rand(self.nwalkers, self.nelec * self.ndim)
-        pos *= (self.init_domain['max'] - self.init_domain['min'])
-        pos += self.init_domain['min']
-        return pos.type(
-            torch.get_default_dtype()).to(
-            device=self.device)
+        pos *= self.init_domain["max"] - self.init_domain["min"]
+        pos += self.init_domain["min"]
+        return pos.type(torch.get_default_dtype()).to(device=self.device)
 
-    def _init_multivar(self):
-        """Initialize the walkers in a sphere covering the molecule
+    def _init_multivar(self) -> torch.Tensor:
+        """Initialize the walkers in a sphere covering the molecule.
 
         Returns:
-            torch.tensor -- positions of the walkers
+            torch.Tensor: positions of the walkers, shape (nwalkers, nelec * ndim)
         """
+        # Create a multivariate normal distribution with the given mean and covariance
         multi = MultivariateNormal(
-            torch.as_tensor(self.init_domain['mean']),
-            torch.as_tensor(self.init_domain['sigma']))
-        pos = multi.sample((self.nwalkers, self.nelec)).type(
-            torch.get_default_dtype())
+            torch.as_tensor(self.init_domain["mean"]),
+            torch.as_tensor(self.init_domain["sigma"]),
+        )
+        # Sample positions for the walkers and cast to the default dtype
+        pos = multi.sample((self.nwalkers, self.nelec)).type(torch.get_default_dtype())
+        # Reshape the sampled positions to match the expected output shape
         pos = pos.view(self.nwalkers, self.nelec * self.ndim)
+        # Move the positions to the appropriate device (CPU or GPU)
         return pos.to(device=self.device)
 
-    def _init_atomic(self):
-        """Initialize the walkers around the atoms
+    def _init_atomic(self) -> torch.Tensor:
+        """Initialize the walkers around the atoms.
+
+        Positions are distributed around atomic coordinates with some randomness.
 
         Returns:
-            torch.tensor -- positions of the walkers
+            torch.Tensor: Positions of the walkers, shape (nwalkers, nelec * ndim).
         """
         pos = torch.zeros(self.nwalkers, self.nelec * self.ndim)
         idx_ref, nelec_tot = [], 0
 
         nelec_placed, natom = [], 0
-        for iat, nelec in enumerate(self.init_domain['atom_nelec']):
+        for iat, nelec in enumerate(self.init_domain["atom_nelec"]):
             idx_ref += [iat] * nelec
             nelec_tot += nelec
             natom += 1
 
         for iw in range(self.nwalkers):
-
             nelec_placed = [0] * natom
             idx = torch.as_tensor(idx_ref)
             idx = idx[torch.randperm(nelec_tot)]
-            xyz = torch.as_tensor(
-                self.init_domain['atom_coords'])[
-                idx, :]
+            xyz = torch.as_tensor(self.init_domain["atom_coords"])[idx, :]
 
             for ielec in range(nelec_tot):
                 _idx = idx[ielec]
                 if nelec_placed[_idx] == 0:
-                    s = 1. / self.init_domain['atom_num'][_idx]
+                    s = 1.0 / self.init_domain["atom_num"][_idx]
                 elif nelec_placed[_idx] < 5:
-                    s = 2. / (self.init_domain['atom_num'][_idx] - 2)
+                    s = 2.0 / (self.init_domain["atom_num"][_idx] - 2)
                 else:
-                    s = 3. / (self.init_domain['atom_num'][_idx] - 3)
-                xyz[ielec,
-                    :] += np.random.normal(scale=s, size=(1, 3))
+                    s = 3.0 / (self.init_domain["atom_num"][_idx] - 3)
+                xyz[ielec, :] += np.random.normal(scale=s, size=(1, 3))
                 nelec_placed[_idx] += 1
 
             pos[iw, :] = xyz.view(-1)
diff --git a/qmctorch/scf/__init__.py b/qmctorch/scf/__init__.py
index ee305cd7..88ef7143 100644
--- a/qmctorch/scf/__init__.py
+++ b/qmctorch/scf/__init__.py
@@ -1,3 +1,3 @@
-__all__ = ['Molecule']
+__all__ = ["Molecule"]
 
 from .molecule import Molecule
diff --git a/qmctorch/scf/calculator/__init__.py b/qmctorch/scf/calculator/__init__.py
index e76d7587..052f89fb 100644
--- a/qmctorch/scf/calculator/__init__.py
+++ b/qmctorch/scf/calculator/__init__.py
@@ -1,4 +1,4 @@
-__all__ = ['CalculatorBase', 'CalculatorADF', 'CalculatorADF2019', 'CalculatorPySCF']
+__all__ = ["CalculatorBase", "CalculatorADF", "CalculatorADF2019", "CalculatorPySCF"]
 
 from .calculator_base import CalculatorBase
 from .adf import CalculatorADF, CalculatorADF2019
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index ebe262fa..5f94a4f3 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -2,49 +2,96 @@
 import shutil
 import warnings
 from types import SimpleNamespace
-
+from typing import BinaryIO, List
 import numpy as np
 
 from ... import log
+from ...utils.constants import BOHR2ANGS
 from .calculator_base import CalculatorBase
 
 try:
     from scm import plams
 except ModuleNotFoundError:
-    warnings.warn('scm python module not found')
+    warnings.warn("scm python module not found")
 
 
 class CalculatorADF(CalculatorBase):
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        atoms: list,
+        atom_coords: list,
+        basis: str,
+        charge: int,
+        spin: int,
+        scf: str,
+        units: str,
+        molname: str,
+        savefile: str,
+    ) -> None:
+        """
+        Initialize the ADF calculator.
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+        Args:
+            atoms (list): List of atom symbols.
+            atom_coords (list): List of atomic coordinates.
+            basis (str): Basis set name.
+            charge (int): Molecular charge.
+            spin (int): Spin multiplicity.
+            scf (str): Self-consistent field method.
+            units (str): Units for atomic coordinates.
+            molname (str): Molecule name.
+            savefile (str): File name to save results.
+
+        Raises:
+            ValueError: If charge or spin is not supported.
 
+        Returns:
+            None
+        """
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, 'adf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "adf",
+            savefile,
+        )
+
+        if charge != 0:
+            raise ValueError("ADF calculator does not support charge yet, open an issue in the repo :)")
+        
+        if spin != 0:
+            raise ValueError("ADF calculator does not support spin polarization yet, open an issue in the repo :)")
 
         # basis from the emma paper
-        self.additional_basis_type = ['VB1', 'VB2', 'VB3',
-                                      'CVB1', 'CVB2', 'CVB3']
+        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.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'
+        self.adf_version = "adf2020+"
+        self.job_name = "".join(self.atoms) + "_" + self.basis_name
+        self.output_file = "adf.rkf"
 
-    def run(self):
+    def run(self) -> SimpleNamespace:
         """Run the calculation using ADF."""
 
         # path needed for the calculation
-        plams_wd = './plams_workdir'
+        plams_wd = "./plams_workdir"
         outputdir_path = os.path.join(
-            plams_wd, os.path.join(self.job_name, self.output_file))
+            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]
+        plams_job = {"adf2020+": plams.AMSJob, "adf2019": plams.ADFJob}[
+            self.adf_version
+        ]
 
         # configure plams and run the calculation
         self.init_plams()
@@ -60,115 +107,140 @@ def run(self):
         if self.savefile:
             shutil.copyfile(outputdir_path, self.output_file)
             self.savefile = self.output_file
-        shutil.rmtree(plams_wd)
+        # shutil.rmtree(plams_wd)
+
+        # fnalize plams
+        self.finish_plams()
 
         return basis
 
-    def init_plams(self):
+    def init_plams(self) -> None:
         """Init PLAMS."""
         plams.init()
         plams.config.log.stdout = -1
+        plams.config.log.file = -1
         plams.config.erase_workdir = True
 
-    def get_plams_molecule(self):
+    def finish_plams(self) -> None:
+        """Finish PLAMS."""
+        plams.finish()
+
+    def get_plams_molecule(self) -> plams.Molecule:
         """Returns a plams molecule object."""
         mol = plams.Molecule()
-        bohr2angs = 0.529177
-        scale = 1.
-        if self.units == 'bohr':
-            scale = bohr2angs
+        bohr2angs = BOHR2ANGS # the coordinate are always in bohr
         for at, xyz in zip(self.atoms, self.atom_coords):
-            xyz = list(scale * np.array(xyz))
+            xyz = list(bohr2angs * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
         return mol
 
-    def get_plams_settings(self):
-        """Returns a plams setting object."""
+    def get_plams_settings(self) -> plams.Settings:
+        """
+        Returns a plams setting object.
+
+        Returns:
+            plams.Settings: A plams setting object.
+        """
 
         sett = plams.Settings()
-        sett.input.ams.Task = 'SinglePoint'
-        
+        sett.input.ams.Task = "SinglePoint"
+
         if self.basis_name.upper() in self.additional_basis_type:
-            sett.input.adf.basis.type = 'DZP'
+            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)
+                    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'
+        sett.input.adf.basis.core = "None"
+        sett.input.adf.symmetry = "nosym"
 
-        if self.scf.lower() == 'hf':
-            sett.input.adf.XC.HartreeFock = ''
+        if self.scf.lower() == "hf":
+            sett.input.adf.XC.HartreeFock = ""
 
-        elif self.scf.lower() == 'dft':
-            sett.input.adf.XC.LDA = 'VWN'
+        elif self.scf.lower() == "dft":
+            sett.input.adf.XC.LDA = "VWN"
 
-        sett.input.adf.relativity.level = 'None'
+        sett.input.adf.relativity.level = "None"
 
         # total energy
         sett.input.adf.totalenergy = True
 
+        # charge info
+        # sett.input.adf.charge = "%d %d" % (self.charge, self.spin)
+
+        # spin info
+        sett.input.unrestricted = False
+        # sett.input.spinpolarization = self.spin
+
         return sett
 
-    def get_basis_data(self, kffile):
-        """Save the basis information needed to compute the AO values."""
+    def get_basis_data(self, kffile: str) -> SimpleNamespace:
+        """
+        Save the basis information needed to compute the AO values.
+
+        Args:
+            kffile (str): Path to the KF file.
 
+        Returns:
+            SimpleNamespace: A namespace containing the basis information.
+        """
         if not os.path.isfile(kffile):
             raise FileNotFoundError(
-                'File %s not found, ADF may have crashed, look into the plams_workdir directory' % kffile)
+                "File %s not found, ADF may have crashed, look into the plams_workdir directory"
+                % kffile
+            )
         kf = plams.KFFile(kffile)
-        status = kf.read('General', 'termination status').strip()
-        if status != 'NORMAL TERMINATION':
-            log.info(
-                '  WARNING : ADF calculation terminated with status')
-            log.info('          : %s' % status)
-            log.info('          : Proceed with caution')
+        status = kf.read("General", "termination status").strip()
+        if status != "NORMAL TERMINATION":
+            log.info("  WARNING : ADF calculation terminated with status")
+            log.info("          : %s" % status)
+            log.info("          : Proceed with caution")
 
         basis = SimpleNamespace()
 
-        basis.TotalEnergy = kf.read('Total Energy', 'Total energy')
-        basis.radial_type = 'sto'
-        basis.harmonics_type = 'cart'
+        basis.TotalEnergy = kf.read("Total Energy", "Total energy")
+        basis.radial_type = "sto"
+        basis.harmonics_type = "cart"
 
-        nao = kf.read('Basis', 'naos')
-        nmo = kf.read('A', 'nmo_A')
+        nao = kf.read("Basis", "naos")
+        nmo = kf.read("A", "nmo_A")
         basis.nao = nao
         basis.nmo = nmo
 
         # number of bas per atom type
-        nbptr = kf.read('Basis', 'nbptr')
+        nbptr = kf.read("Basis", "nbptr")
 
         # number of atom per atom typ
-        nqptr = kf.read('Geometry', 'nqptr')
-        atom_type = kf.read('Geometry', 'atomtype').split()
+        nqptr = kf.read("Geometry", "nqptr")
+        atom_type = kf.read("Geometry", "atomtype").split()
 
         # number of bas per atom type
-        nshells = np.array([nbptr[i] - nbptr[i - 1]
-                            for i in range(1, len(nbptr))])
+        nshells = np.array([nbptr[i] - nbptr[i - 1] for i in range(1, len(nbptr))])
 
         # kx/ky/kz/kr exponent per atom type
-        bas_kx = self.read_array(kf, 'Basis', 'kx')
-        bas_ky = self.read_array(kf, 'Basis', 'ky')
-        bas_kz = self.read_array(kf, 'Basis', 'kz')
-        bas_kr = self.read_array(kf, 'Basis', 'kr')
+        bas_kx = self.read_array(kf, "Basis", "kx")
+        bas_ky = self.read_array(kf, "Basis", "ky")
+        bas_kz = self.read_array(kf, "Basis", "kz")
+        bas_kr = self.read_array(kf, "Basis", "kr")
 
         # bas exp/coeff/norm per atom type
-        bas_exp = self.read_array(kf, 'Basis', 'alf')
-        bas_norm = self.read_array(kf, 'Basis', 'bnorm')
+        bas_exp = self.read_array(kf, "Basis", "alf")
+        bas_norm = self.read_array(kf, "Basis", "bnorm")
 
         basis_nshells = []
         basis_bas_kx, basis_bas_ky, basis_bas_kz = [], [], []
         basis_bas_kr = []
         basis_bas_exp, basis_bas_norm = [], []
 
-        for iat, at in enumerate(atom_type):
-
+        for iat, _ in enumerate(atom_type):
             number_copy = nqptr[iat + 1] - nqptr[iat]
             idx_bos = list(range(nbptr[iat] - 1, nbptr[iat + 1] - 1))
 
@@ -179,8 +251,7 @@ def get_basis_data(self, kffile):
             basis_bas_kz += list(bas_kz[idx_bos]) * number_copy
             basis_bas_kr += list(bas_kr[idx_bos]) * number_copy
             basis_bas_exp += list(bas_exp[idx_bos]) * number_copy
-            basis_bas_norm += list(
-                bas_norm[idx_bos]) * number_copy
+            basis_bas_norm += list(bas_norm[idx_bos]) * number_copy
 
         basis.nshells = basis_nshells
         basis.nao_per_atom = basis_nshells
@@ -196,11 +267,10 @@ def get_basis_data(self, kffile):
         basis.bas_coeffs = np.ones_like(basis_bas_exp)
         basis.bas_norm = np.array(basis_bas_norm)
 
-        basis.atom_coords_internal = np.array(
-            kf.read('Geometry', 'xyz')).reshape(-1, 3)
+        basis.atom_coords_internal = np.array(kf.read("Geometry", "xyz")).reshape(-1, 3)
 
         # Molecular orbitals
-        mos = np.array(kf.read('A', 'Eigen-Bas_A'))
+        mos = np.array(kf.read("A", "Eigen-Bas_A"))
         mos = mos.reshape(nmo, nao).T
 
         # normalize the MO
@@ -208,12 +278,12 @@ def get_basis_data(self, kffile):
         # mos = self.normalize_columns(mos)
 
         # orbital that take part in the rep
-        npart = np.array(kf.read('A', 'npart'))-1
+        npart = np.array(kf.read("A", "npart")) - 1
 
         # create permutation matrix
         perm_mat = np.zeros((basis.nao, basis.nao))
         for i in range(basis.nao):
-            perm_mat[npart[i], i] = 1.
+            perm_mat[npart[i], i] = 1.0
 
         # reorder the basis function
         basis.mos = perm_mat @ mos
@@ -221,63 +291,102 @@ def get_basis_data(self, kffile):
         return basis
 
     @staticmethod
-    def read_array(kf, section, name):
+    def read_array(kf: BinaryIO , section: str, name: str) -> np.ndarray:
         """read a data from the kf file
 
         Args:
-            kf (file handle): kf file
+            kf (BinaryIO): kf file
             section (str): name of the section
             name (str): name of the property
 
         Returns:
-            np.data: data
+            np.ndarray: data
         """
         data = np.array(kf.read(section, name))
         if data.shape == ():
             data = np.array([data])
         return data
-        
+
+
 class CalculatorADF2019(CalculatorADF):
+    def __init__(
+        self,
+        atoms: List[str],
+        atom_coords: List[np.ndarray],
+        basis: str,
+        charge: int,
+        spin: int,
+        scf: str,
+        units: str,
+        molname: str,
+        savefile: str,
+    ):
+        """
+        Initialize the ADF2019 calculator.
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+        Args:
+            atoms (list): List of atom symbols.
+            atom_coords (list): List of atomic coordinates.
+            basis (str): Basis set name.
+            charge (int): Molecular charge.
+            spin (int): Spin multiplicity.
+            scf (str): Self-consistent field method.
+            units (str): Units of the coordinates; 'bohr' or 'angs'.
+            molname (str): Molecule name.
+            savefile (str): File name to save results.
 
+        Returns:
+            None
+        """
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, savefile)
+            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+        )
 
-        self.adf_version = 'adf2019'
-        self.job_name = ''.join(self.atoms) + '_' + self.basis_name
-        self.output_file = self.job_name + '.t21'
+        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."""
+    def get_plams_molecule(self) -> plams.Molecule:
+        """Returns a plams molecule object.
+
+        Returns:
+            plams.Molecule: 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."""
+    def get_plams_settings(self) -> plams.Settings:
+        """Returns a plams setting object.
+
+        Returns:
+            plams.Settings: 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'
+        sett.input.basis.core = "None"
+        sett.input.symmetry = "nosym"
 
-        if self.scf.lower() == 'hf':
-            sett.input.XC.HartreeFock = ''
+        if self.scf.lower() == "hf":
+            sett.input.XC.HartreeFock = ""
 
-        elif self.scf.lower() == 'dft':
-            sett.input.XC.LDA = 'VWN'
+        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'
+        if self.units == "angs":
+            sett.input.units.length = "Angstrom"
+        elif self.units == "bohr":
+            sett.input.units.length = "Bohr"
 
         # total energy
         sett.input.totalenergy = True
 
+        # charge info
+        sett.input.charge = "%d %d" % (self.charge, self.spin)
+
         return sett
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index a2d25d2e..007a69a0 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -2,11 +2,24 @@
 
 
 class CalculatorBase:
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, calcname, savefile):
-
+    def __init__(
+        self,
+        atoms,
+        atom_coords,
+        basis,
+        charge,
+        spin,
+        scf,
+        units,
+        molname,
+        calcname,
+        savefile,
+    ):
         self.atoms = atoms
         self.atom_coords = atom_coords
         self.basis_name = basis
+        self.charge = charge
+        self.spin = spin
         self.scf = scf
         self.units = units
         self.molname = molname
@@ -14,12 +27,10 @@ def __init__(self, atoms, atom_coords, basis, scf, units, molname, calcname, sav
         self.savefile = savefile
 
     def run(self):
-        raise NotImplementedError(
-            'Implement a run method in your calculator.')
+        raise NotImplementedError("Implement a run method in your calculator.")
 
     def save_data(self):
-        raise NotImplementedError(
-            'Implement a save_data method in your calculator.')
+        raise NotImplementedError("Implement a save_data method in your calculator.")
 
     @staticmethod
     def normalize_columns(mat):
diff --git a/qmctorch/scf/calculator/pyscf.py b/qmctorch/scf/calculator/pyscf.py
index 56573b22..e5816819 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -1,4 +1,5 @@
 from types import SimpleNamespace
+from typing import List
 import itertools
 import numpy as np
 from pyscf import gto, scf, dft
@@ -8,14 +9,56 @@
 
 
 class CalculatorPySCF(CalculatorBase):
-
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
-
+    def __init__(
+        self,
+        atoms: List[str],
+        atom_coords: List[np.ndarray],
+        basis: str,
+        charge: int,
+        spin: int,
+        scf: str,
+        units: str,
+        molname: str,
+        savefile: str,
+    ) -> None:
+        """
+        Initialize the PySCF calculator.
+
+        Args:
+            atoms (list): List of atom symbols.
+            atom_coords (list): List of atomic coordinates.
+            basis (str): Basis set name.
+            charge (int): Molecular charge.
+            spin (int): Spin multiplicity.
+            scf (str): Self-consistent field method.
+            units (str): Units of the coordinates; 'bohr' or 'angs'.
+            molname (str): Molecule name.
+            savefile (str): File name to save results.
+
+        Returns:
+            None
+        """
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, 'pyscf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "pyscf",
+            savefile,
+        )
+
+    def run(self) -> SimpleNamespace:
+        """
+        Run the scf calculation using PySCF.
 
-    def run(self):
-        """Run the scf calculation using PySCF."""
+        Returns:
+            SimpleNamespace: Contains the basis set data.
+        """
 
         # refresh the atom positions if necessary
         atom_str = self.get_atoms_str()
@@ -23,37 +66,43 @@ def run(self):
         # pyscf calculation
         mol = gto.M(
             atom=atom_str,
+            spin=self.spin,
+            charge=self.charge,
             basis=self.basis_name,
-            unit='Bohr',
-            cart=False)
+            unit="Bohr",
+            cart=False,
+        )
 
-        if self.scf.lower() == 'hf':
+        if self.scf.lower() == "hf":
             pyscf_data = scf.RHF(mol).run()
 
-        elif self.scf.lower() == 'dft':
+        elif self.scf.lower() == "dft":
             pyscf_data = dft.RKS(mol)
-            pyscf_data.xc = 'lda, vwn'
+            pyscf_data.xc = "lda, vwn"
             pyscf_data = pyscf_data.newton()
             pyscf_data.kernel()
 
         if self.savefile:
-            save_file_name = self.molname + '_pyscf.chkfile'
+            save_file_name = self.molname + "_pyscf.chkfile"
             shutil.copyfile(pyscf_data.chkfile, save_file_name)
             self.savefile = save_file_name
 
         basis = self.get_basis_data(mol, pyscf_data)
         return basis
 
-    def get_basis_data(self, mol, rhf):
-        """Save the data to HDF5
+    def get_basis_data(self, mol: gto.M, rhf: scf.RHF) -> SimpleNamespace:
+        """Get the information about the basis
 
         Arguments:
             mol {pyscf.gto.M} -- psycf Molecule
             rhf {pyscf.scf} -- scf object
+
+        Returns:
+            SimpleNamespace -- basis data
         """
 
         # sphereical quantum nummbers
-        mvalues = {0: [0], 1: [-1,0,1], 2: [-2,-1,0,1,2]}
+        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]}
@@ -62,9 +111,8 @@ def get_basis_data(self, mol, rhf):
 
         basis = SimpleNamespace()
         basis.TotalEnergy = rhf.e_tot
-        basis.radial_type = 'gto_pure'
-        basis.harmonics_type = 'cart'
-
+        basis.radial_type = "gto_pure"
+        basis.harmonics_type = "cart"
 
         # number of AO / MO
         # can be different if d or f orbs are present
@@ -86,7 +134,6 @@ def get_basis_data(self, mol, rhf):
         iao = 0
         ishell = 0
         for ibas in range(mol.nbas):
-
             # number of contracted gto per shell
             nctr = mol.bas_nctr(ibas)
 
@@ -102,17 +149,16 @@ def get_basis_data(self, mol, rhf):
 
             # coeffs and exponents
             coeffs = mol.bas_ctr_coeff(ibas)
-            exps =  mol.bas_exp(ibas)
+            exps = mol.bas_exp(ibas)
 
             # deal with  multiple zeta
             if coeffs.shape != (nprim, nctr):
-                raise ValueError('Contraction coefficients issue')
-         
+                raise ValueError("Contraction coefficients issue")
+
             ictr = 0
             while ictr < nctr:
-
                 n = bas_n_ori[ishell]
-                coeffs_ictr = coeffs[:,ictr] / (ictr+1)
+                coeffs_ictr = coeffs[:, ictr] / (ictr + 1)
 
                 # coeffs/exp
                 bas_coeff += coeffs_ictr.flatten().tolist() * ncart_comp
@@ -158,15 +204,16 @@ def get_basis_data(self, mol, rhf):
         intervals = np.concatenate(([0], np.cumsum(nshells)))
 
         basis.nao_per_atom = []
-        for i in range(len(intervals)-1):
-            s, e = intervals[i], intervals[i+1]
+        for i in range(len(intervals) - 1):
+            s, e = intervals[i], intervals[i + 1]
             nao = len(np.unique(basis.index_ctr[s:e]))
             basis.nao_per_atom.append(nao)
 
         # determine the number of contraction per
         # atomic orbital
         basis.nctr_per_ao = np.array(
-            [len(list(y)) for _, y in itertools.groupby(index_ctr)])
+            [len(list(y)) for _, y in itertools.groupby(index_ctr)]
+        )
 
         basis.bas_coeffs = np.array(bas_coeff)
         basis.bas_exp = np.array(bas_exp)
@@ -193,24 +240,22 @@ def get_basis_data(self, mol, rhf):
 
         return basis
 
-    def get_atoms_str(self):
-        """Refresh the atom string (use after atom move). """
-        atoms_str = ''
+    def get_atoms_str(self) -> str:
+        """Refresh the atom string (use after atom move)."""
+        atoms_str = ""
         natom = len(self.atoms)
 
         for iA in range(natom):
-            atoms_str += self.atoms[iA] + ' '
-            atoms_str += ' '.join(str(xi)
-                                  for xi in self.atom_coords[iA])
-            atoms_str += ';'
+            atoms_str += self.atoms[iA] + " "
+            atoms_str += " ".join(str(xi) for xi in self.atom_coords[iA])
+            atoms_str += ";"
         return atoms_str
 
     @staticmethod
-    def get_bas_n(mol):
-
-        recognized_labels = ['s','p','d']
+    def get_bas_n(mol: gto.M) -> List[str]:
+        recognized_labels = ["s", "p", "d"]
 
-        label2int = {'s': 1, 'p': 2, 'd': 3}
+        label2int = {"s": 1, "p": 2, "d": 3}
         labels = [l[:3] for l in mol.cart_labels(fmt=False)]
         unique_labels = []
         for l in labels:
@@ -219,10 +264,13 @@ def get_bas_n(mol):
         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')
+            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 b589b575..c2429a0b 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -1,151 +1,178 @@
 import os
-import math
 import numpy as np
+from typing import Dict, List
 from mendeleev import element
 from types import SimpleNamespace
 import h5py
-from mpi4py import MPI
+
 from .calculator import CalculatorADF, CalculatorPySCF, CalculatorADF2019
 
 from ..utils import dump_to_hdf5, load_from_hdf5, bytes2str
+from ..utils.constants import ANGS2BOHR
 from .. import log
 
+try:
+    from mpi4py import MPI
+except ModuleNotFoundError:
+    log.info("  MPI not found.")
 
-class Molecule:
 
-    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):
+class Molecule:
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        atom: str = None,
+        calculator: str = "adf",
+        scf: str = "hf",
+        basis: str = "dzp",
+        unit: str = "bohr",
+        charge: int = 0,
+        spin: int = 0,
+        name: str = None,
+        load: str = None,
+        save_scf_file: bool = False,
+        redo_scf: bool = False,
+        rank: int = 0,
+        mpi_size: int = 0,
+    ) -> None:
         """Create a molecule in QMCTorch
 
         Args:
-            atom (str or None, optional): defines the atoms and their positions. Defaults to None.
+            atom (str, 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; '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
-            redo_scf (bool, optional): if true ignore existing hdf5 file and redo the scf calculation
+                - <file>.xyz : Provide the path to an .xyz file containing the atomic coordinates
+            calculator (str, optional): Select SCF calculator. Defaults to 'adf'.
+                - 'pyscf' : PySCF calculator
+                - 'adf' : ADF2020+ calculator
+                - 'adf2019' : ADF2019 calculator
+            scf (str, optional): Select SCF level of theory. Defaults to 'hf'.
+                - 'hf' : Hartree-Fock calculation
+                - 'dft' : Density Functional Theory using LDA
+            charge (int, optional): Extra charge on the molecule. Defaults to 0.
+            spin (int, optional): Excess of spin-up electrons on the molecule. Defaults to 0.
+            basis (str, optional): Select the basis set. Defaults to 'dzp'.
+            unit (str, optional): Units of the coordinates; 'bohr' or 'angs'. Defaults to 'bohr'.
+            name (str, optional): Name of the molecule. Defaults to None.
+            load (str, 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.
+            redo_scf (bool, optional): If true, ignore existing HDF5 file and redo SCF calculation.
             rank (int, optional): Rank of the process. Defaults to 0.
+            mpi_size (int, optional): Size of the MPI world.
 
+        Returns:
+            None
+        
         Examples:
             >>> from qmctorch.scf import Molecule
             >>> mol = Molecule(atom='H 0 0 0; H 0 0 1', unit='angs',
             ...                calculator='adf', basis='dzp')
         """
 
-        self.atom_coords = []
-        self.atomic_nelec = []
-        self.atomic_number = []
-        self.atoms = []
-        self.atoms_str = atom
-        self.hdf5file = None
-        self.max_angular = 2
-        self.name = name
-        self.natom = 0
-        self.ndown = 0
-        self.nelec = 0
-        self.nup = 0
-        self.unit = unit
-        self.basis = SimpleNamespace()
-        self.calculator_name = calculator
-        self.basis_name = basis
-        self.save_scf_file = save_scf_file
-        self.scf_level = scf
+        self.atom_coords: list = []
+        self.atomic_nelec: list = []
+        self.atomic_number: list = []
+        self.atoms: list = []
+        self.atoms_str: str = atom
+        self.hdf5file: str = None
+        self.max_angular: int = 2
+        self.name: str = name
+        self.natom: int = 0
+        self.ndown: int = 0
+        self.nelec: int = 0
+        self.nup: int = 0
+        self.charge: int = charge
+        self.spin: int = spin
+        self.unit: str = unit
+        self.basis: SimpleNamespace = SimpleNamespace()
+        self.calculator_name: str = calculator
+        self.basis_name: str = basis
+        self.save_scf_file: bool = save_scf_file
+        self.scf_level: str = scf
 
         if rank == 0:
-            log.info('')
-            log.info(' SCF Calculation')
+            log.info("")
+            log.info(" SCF Calculation")
 
         # load an existing hdf5 file
         if load is not None:
-            log.info('  Loading data from {file}', file=load)
+            log.info("  Loading data from {file}", file=load)
             self._load_hdf5(load)
             self.hdf5file = load
 
         else:
-
             # extract the atom names/positions from
             # the atom kwargs
             self._process_atom_str()
 
             # name of the hdf5 file
-            self.hdf5file = '_'.join(
-                [self.name, calculator, basis]) + '.hdf5'
+            self.hdf5file = "_".join([self.name, calculator, basis]) + ".hdf5"
 
             if rank == 0:
-
-                if self.unit not in ['angs', 'bohr']:
-                    raise ValueError('unit should be angs or bohr')
+                if self.unit not in ["angs", "bohr"]:
+                    raise ValueError("unit should be angs or bohr")
 
                 # force a redo of the sc calculation
                 if os.path.isfile(self.hdf5file) and redo_scf:
-                    log.info('  Removing {file} and redo SCF calculations',
-                             file=self.hdf5file)
+                    log.info(
+                        "  Removing {file} and redo SCF calculations",
+                        file=self.hdf5file,
+                    )
                     os.remove(self.hdf5file)
 
                 # deals with existing files
                 if os.path.isfile(self.hdf5file):
-                    log.info('  Reusing scf results from {file}',
-                             file=self.hdf5file)
+                    log.info("  Reusing scf results from {file}", file=self.hdf5file)
                     self.basis = self._load_basis()
 
                 # perform the scf calculation
                 else:
-                    log.info('  Running scf  calculation')
-
-                    calc = {'adf2019': CalculatorADF2019,
-                            'adf': CalculatorADF,
-                            'pyscf': CalculatorPySCF}[calculator]
-
-                    self.calculator = calc(self.atoms,
-                                           self.atom_coords,
-                                           basis,
-                                           self.scf_level,
-                                           self.unit,
-                                           self.name,
-                                           self.save_scf_file)
+                    log.info("  Running scf  calculation")
+
+                    calc = {
+                        "adf2019": CalculatorADF2019,
+                        "adf": CalculatorADF,
+                        "pyscf": CalculatorPySCF,
+                    }[calculator]
+
+                    self.calculator = calc(
+                        self.atoms,
+                        self.atom_coords,
+                        basis,
+                        self.charge,
+                        self.spin,
+                        self.scf_level,
+                        self.unit,
+                        self.name,
+                        self.save_scf_file,
+                    )
 
                     self.basis = self.calculator.run()
                     self.save_scf_file = self.calculator.savefile
 
-                    dump_to_hdf5(self, self.hdf5file,
-                                 root_name='molecule')
+                    dump_to_hdf5(self, self.hdf5file, root_name="molecule")
 
                     self._check_basis()
                     self.log_data()
 
-            MPI.COMM_WORLD.barrier()
-            if rank != 0:
-                log.info(
-                    '  Loading data from {file}', file=self.hdf5file)
-                self._load_hdf5(self.hdf5file)
-
-    def log_data(self):
-
-        log.info('  Molecule name       : {0}', self.name)
-        log.info('  Number of electrons : {0}', self.nelec)
+            if mpi_size != 0:
+                MPI.COMM_WORLD.barrier()
+
+                if rank != 0:
+                    log.info("  Loading data from {file}", file=self.hdf5file)
+                    self._load_hdf5(self.hdf5file)
+
+    def log_data(self) -> None:
+        log.info("  Molecule name       : {0}", self.name)
+        log.info("  Number of electrons : {0}", self.nelec)
+        log.info("  SCF calculator      : {0}", self.calculator_name)
+        log.info("  Basis set           : {0}", self.basis_name)
+        log.info("  SCF                 : {0}", self.scf_level.upper())
+        log.info("  Number of AOs       : {0}", self.basis.nao)
+        log.info("  Number of MOs       : {0}", self.basis.nmo)
         log.info(
-            '  SCF calculator      : {0}', self.calculator_name)
-        log.info('  Basis set           : {0}', self.basis_name)
-        log.info(
-            '  SCF                 : {0}', self.scf_level.upper())
-        log.info('  Number of AOs       : {0}', self.basis.nao)
-        log.info('  Number of MOs       : {0}', self.basis.nmo)
-        log.info(
-            '  SCF Energy          : {:.3f} Hartree'.format(self.get_total_energy()))
+            "  SCF Energy          : {:.3f} Hartree".format(self.get_total_energy())
+        )
 
-    def domain(self, method):
+    def domain(self, method: str) -> Dict:
         """Returns information to initialize the walkers
 
         Args:
@@ -162,46 +189,43 @@ def domain(self, method):
             >>> domain = mol.domain('atomic')
         """
         domain = dict()
-        domain['method'] = method
+        domain["method"] = method
 
-        if method == 'center':
-            domain['center'] = np.mean(self.atom_coords, 0)
+        if method == "center":
+            domain["center"] = np.mean(self.atom_coords, 0)
 
-        elif method == 'uniform':
-            domain['min'] = np.min(self.atom_coords) - 0.5
-            domain['max'] = np.max(self.atom_coords) + 0.5
+        elif method == "uniform":
+            domain["min"] = np.min(self.atom_coords) - 0.5
+            domain["max"] = np.max(self.atom_coords) + 0.5
 
-        elif method == 'normal':
-            domain['mean'] = np.mean(self.atom_coords, 0)
-            domain['sigma'] = np.diag(
-                np.std(self.atom_coords, 0) + 0.25)
+        elif method == "normal":
+            domain["mean"] = np.mean(self.atom_coords, 0)
+            domain["sigma"] = np.diag(np.std(self.atom_coords, 0) + 0.25)
 
-        elif method == 'atomic':
-            domain['atom_coords'] = self.atom_coords
-            domain['atom_num'] = self.atomic_number
-            domain['atom_nelec'] = self.atomic_nelec
+        elif method == "atomic":
+            domain["atom_coords"] = self.atom_coords
+            domain["atom_num"] = self.atomic_number
+            domain["atom_nelec"] = self.atomic_nelec
 
         else:
-            raise ValueError(
-                'Method to initialize the walkers not recognized')
+            raise ValueError("Method to initialize the walkers not recognized")
 
         return domain
 
-    def _process_atom_str(self):
+    def _process_atom_str(self) -> None:
         """Process the atom description."""
 
-        if self.atoms_str.endswith('.xyz'):
+        if self.atoms_str.endswith(".xyz"):
             if os.path.isfile(self.atoms_str):
                 atoms = self._read_xyz_file()
             else:
-                raise FileNotFoundError(
-                    'File %s not  found' % self.atoms_str)
+                raise FileNotFoundError("File %s not  found" % self.atoms_str)
         else:
-            atoms = self.atoms_str.split(';')
+            atoms = self.atoms_str.split(";")
 
         self._get_atomic_properties(atoms)
 
-    def _get_atomic_properties(self, atoms):
+    def _get_atomic_properties(self, atoms: str) -> None:
         """Generates the atomic propeties of the molecule
 
         Args:
@@ -212,52 +236,63 @@ def _get_atomic_properties(self, atoms):
         for a in atoms:
             atom_data = a.split()
             self.atoms.append(atom_data[0])
-            x, y, z = float(atom_data[1]), float(
-                atom_data[2]), float(atom_data[3])
+            x, y, z = float(atom_data[1]), float(atom_data[2]), float(atom_data[3])
 
             conv2bohr = 1
-            if self.unit == 'angs':
-                conv2bohr = 1.8897259886
-            self.atom_coords.append(
-                [x * conv2bohr, y * conv2bohr, z * conv2bohr])
+            if self.unit == "angs":
+                conv2bohr = ANGS2BOHR
+            self.atom_coords.append([x * conv2bohr, y * conv2bohr, z * conv2bohr])
 
-            self.atomic_number.append(
-                element(atom_data[0]).atomic_number)
+            self.atomic_number.append(element(atom_data[0]).atomic_number)
             self.atomic_nelec.append(element(atom_data[0]).electrons)
             self.nelec += element(atom_data[0]).electrons
 
+        # add extra charge on the molecule
+        self.nelec += self.charge
+
         # size of the system
         self.natom = len(self.atoms)
-        if self.nelec % 2 != 0:
-            raise ValueError("Only equal spin up/down supported.")
-        self.nup = math.ceil(self.nelec / 2)
-        self.ndown = math.floor(self.nelec / 2)
+        if (self.nelec - self.spin) % 2 != 0:
+            raise ValueError(
+                "%d electrons and spin %d doesn't make sense" % (self.nelec, self.spin)
+            )
+        self.nup = int((self.nelec - self.spin) / 2) + self.spin
+        self.ndown = int((self.nelec - self.spin) / 2)
 
         # name of the system
         if self.name is None:
             self.name = self._get_mol_name(self.atoms)
         self.atoms = np.array(self.atoms)
 
-    def _read_xyz_file(self):
+    def _read_xyz_file(self) -> List:
         """Process a xyz file containing the data
 
         Returns:
             list -- atoms and xyz position
         """
-        with open(self.atoms_str, 'r') as f:
+        with open(self.atoms_str, "r") as f:
             data = f.readlines()
 
         natom = int(data[0])
-        atoms = data[2:2+natom]
-        self.atoms_str = ''
+        atoms = data[2 : 2 + natom]
+        self.atoms_str = ""
         for a in atoms[:-1]:
-            self.atoms_str += a + '; '
+            self.atoms_str += a + "; "
         self.atoms_str += atoms[-1]
         return atoms
 
     @staticmethod
-    def _get_mol_name(atoms):
-        mol_name = ''
+    def _get_mol_name(atoms: List[str]) -> str:
+        """
+        Generate a molecule name from the list of atoms.
+
+        Args:
+            atoms (List[str]): List of atoms in the molecule
+
+        Returns:
+            str: The molecule name
+        """
+        mol_name = ""
         unique_atoms = list(set(atoms))
         for ua in unique_atoms:
             mol_name += ua
@@ -266,56 +301,54 @@ def _get_mol_name(atoms):
                 mol_name += str(nat)
         return mol_name
 
-    def _load_basis(self):
+    def _load_basis(self) -> SimpleNamespace:
         """Get the basis information needed to compute the AO values."""
 
-        h5 = h5py.File(self.hdf5file, 'r')
-        basis_grp = h5['molecule']['basis']
+        h5 = h5py.File(self.hdf5file, "r")
+        basis_grp = h5["molecule"]["basis"]
         self.basis = SimpleNamespace()
 
-        self.basis.radial_type = bytes2str(
-            basis_grp['radial_type'][()])
-        self.basis.harmonics_type = bytes2str(
-            basis_grp['harmonics_type'][()])
+        self.basis.radial_type = bytes2str(basis_grp["radial_type"][()])
+        self.basis.harmonics_type = bytes2str(basis_grp["harmonics_type"][()])
 
-        self.basis.nao = int(basis_grp['nao'][()])
-        self.basis.nmo = int(basis_grp['nmo'][()])
+        self.basis.nao = int(basis_grp["nao"][()])
+        self.basis.nmo = int(basis_grp["nmo"][()])
 
-        self.basis.nshells = basis_grp['nshells'][()]
-        self.basis.nao_per_atom = basis_grp['nao_per_atom'][()]
-        self.basis.index_ctr = basis_grp['index_ctr'][()]
-        self.basis.nctr_per_ao = basis_grp['nctr_per_ao'][()]
+        self.basis.nshells = basis_grp["nshells"][()]
+        self.basis.nao_per_atom = basis_grp["nao_per_atom"][()]
+        self.basis.index_ctr = basis_grp["index_ctr"][()]
+        self.basis.nctr_per_ao = basis_grp["nctr_per_ao"][()]
 
-        self.basis.bas_exp = basis_grp['bas_exp'][()]
-        self.basis.bas_coeffs = basis_grp['bas_coeffs'][()]
+        self.basis.bas_exp = basis_grp["bas_exp"][()]
+        self.basis.bas_coeffs = basis_grp["bas_coeffs"][()]
 
-        self.basis.atom_coords_internal = basis_grp['atom_coords_internal'][(
-        )]
+        self.basis.atom_coords_internal = basis_grp["atom_coords_internal"][()]
 
-        self.basis.TotalEnergy = basis_grp['TotalEnergy'][()]
-        self.basis.mos = basis_grp['mos'][()]
+        self.basis.TotalEnergy = basis_grp["TotalEnergy"][()]
+        self.basis.mos = basis_grp["mos"][()]
 
-        if self.basis.harmonics_type == 'cart':
-            self.basis.bas_kr = basis_grp['bas_kr'][()]
-            self.basis.bas_kx = basis_grp['bas_kx'][()]
-            self.basis.bas_ky = basis_grp['bas_ky'][()]
-            self.basis.bas_kz = basis_grp['bas_kz'][()]
+        if self.basis.harmonics_type == "cart":
+            self.basis.bas_kr = basis_grp["bas_kr"][()]
+            self.basis.bas_kx = basis_grp["bas_kx"][()]
+            self.basis.bas_ky = basis_grp["bas_ky"][()]
+            self.basis.bas_kz = basis_grp["bas_kz"][()]
 
-        elif self.basis.harmonics_type == 'sph':
-            self.basis.bas_n = basis_grp['bas_n'][()]
-            self.basis.bas_l = basis_grp['bas_l'][()]
-            self.basis.bas_m = basis_grp['bas_m'][()]
+        elif self.basis.harmonics_type == "sph":
+            self.basis.bas_n = basis_grp["bas_n"][()]
+            self.basis.bas_l = basis_grp["bas_l"][()]
+            self.basis.bas_m = basis_grp["bas_m"][()]
 
         else:
             raise ValueError(
-                'Harmonics type should be cart or sph \
-                but %s was found in %s' % (self.basis.harmonics_type,
-                                           self.hdf5file))
+                "Harmonics type should be cart or sph \
+                but %s was found in %s"
+                % (self.basis.harmonics_type, self.hdf5file)
+            )
 
         h5.close()
         return self.basis
 
-    def print_total_energy(self):
+    def print_total_energy(self) -> None:
         """Print the SCF energy of the molecule.
 
         Examples::
@@ -323,33 +356,41 @@ def print_total_energy(self):
             >>> mol.print_total_energy()
         """
         e = self.get_total_energy()
-        log.info('== SCF Energy : {e}', e=e)
+        log.info("== SCF Energy : {e}", e=e)
 
-    def get_total_energy(self):
+    def get_total_energy(self) -> float:
         """Get the value of the total energy."""
-        h5 = h5py.File(self.hdf5file, 'r')
-        e = h5['molecule']['basis']['TotalEnergy'][()]
+        h5 = h5py.File(self.hdf5file, "r")
+        e = h5["molecule"]["basis"]["TotalEnergy"][()]
         h5.close()
         return e
 
-    def _check_basis(self):
+    def _check_basis(self) -> None:
         """Check if the basis contains all the necessary fields."""
 
-        names = ['bas_coeffs', 'bas_exp', 'nshells',
-                 'atom_coords_internal', 'nao', 'nmo',
-                 'index_ctr', 'mos', 'TotalEnergy']
+        names = [
+            "bas_coeffs",
+            "bas_exp",
+            "nshells",
+            "atom_coords_internal",
+            "nao",
+            "nmo",
+            "index_ctr",
+            "mos",
+            "TotalEnergy",
+        ]
 
-        if self.basis.harmonics_type == 'cart':
-            names += ['bas_kx', 'bas_ky', 'bas_kz', 'bas_kr']
+        if self.basis.harmonics_type == "cart":
+            names += ["bas_kx", "bas_ky", "bas_kz", "bas_kr"]
 
-        elif self.basis.harmonics_type == 'sph':
-            names += ['bas_n', 'bas_l', 'bas_m']
+        elif self.basis.harmonics_type == "sph":
+            names += ["bas_n", "bas_l", "bas_m"]
 
         for n in names:
             if not hasattr(self.basis, n):
-                raise ValueError(n, ' not in the basis namespace')
+                raise ValueError(n, " not in the basis namespace")
 
-    def _load_hdf5(self, filename):
+    def _load_hdf5(self, filename: str) -> None:
         """Load a molecule from hdf5
 
         Args:
@@ -357,26 +398,26 @@ def _load_hdf5(self, filename):
         """
 
         # load the data
-        load_from_hdf5(self, filename, 'molecule')
+        load_from_hdf5(self, filename, "molecule")
 
         # cast some of the important data type
         # should be done by the hdf5_utils in the future
-        self.atoms = self.atoms.astype('U')
+        self.atoms = self.atoms.astype("U")
         self.basis.nao = int(self.basis.nao)
         self.basis.nmo = int(self.basis.nmo)
 
-        cast_fn = {'nelec': int,
-                   'nup': int,
-                   'ndown': int,
-                   'atoms': lambda x: x.astype('U'),
-                   'atomic_nelec': lambda x: [int(i) for i in x]}
+        cast_fn = {
+            "nelec": int,
+            "nup": int,
+            "ndown": int,
+            "atoms": lambda x: x.astype("U"),
+            "atomic_nelec": lambda x: [int(i) for i in x],
+        }
 
         for name, fn in cast_fn.items():
             self.__setattr__(name, fn(self.__getattribute__(name)))
 
-        cast_fn = {'nao': int,
-                   'nmo': int}
+        cast_fn = {"nao": int, "nmo": int}
 
         for name, fn in cast_fn.items():
-            self.basis.__setattr__(
-                name, fn(self.basis.__getattribute__(name)))
+            self.basis.__setattr__(name, fn(self.basis.__getattribute__(name)))
diff --git a/qmctorch/solver/__init__.py b/qmctorch/solver/__init__.py
index b53cb8c2..865714fc 100644
--- a/qmctorch/solver/__init__.py
+++ b/qmctorch/solver/__init__.py
@@ -1,5 +1,4 @@
-__all__ = ['SolverBase', 'Solver',
-           'SolverMPI']
+__all__ = ["SolverBase", "Solver", "SolverMPI"]
 
 from .solver_base import SolverBase
 from .solver import Solver
diff --git a/qmctorch/solver/loss.py b/qmctorch/solver/loss.py
new file mode 100644
index 00000000..dc79c688
--- /dev/null
+++ b/qmctorch/solver/loss.py
@@ -0,0 +1,145 @@
+from typing import ContextManager, Tuple
+import torch
+from torch import nn
+from ..wavefunction import WaveFunction
+
+class Loss(nn.Module):
+    def __init__(self, 
+                 wf: WaveFunction, 
+                 method: str = "energy", 
+                 clip: bool = False,
+                 clip_threshold: int = 5):
+        """Defines the loss to use during the optimization
+
+        Arguments:
+            wf {Wavefunction} -- wave function object used
+
+        Keyword Arguments:
+            method {str} -- method to use  (default: {'energy'})
+                            (energy, variance, weighted-energy,
+                            weighted-variance)
+            clip {bool} -- clip the values that are +/- % sigma away from
+                           the mean (default: {False})
+        """
+
+        super(Loss, self).__init__()
+
+        self.wf = wf
+        self.method = method
+        self.clip = clip
+
+        # by default we use weights
+        # that are needed if we do
+        # not resample at every time step
+        self.use_weight = True
+
+        # number of +/- std for clipping
+        # Excludes values + /- Nstd x std the mean of the eloc
+        self.clip_num_std = clip_threshold
+
+        # select loss function
+        self.loss_fn = {"energy": torch.mean, "variance": torch.var}[method]
+
+        # init values of the weights
+        self.weight = {"psi": None, "psi0": None}
+
+    def forward(
+        self, 
+        pos: torch.Tensor, 
+        no_grad: bool = False,
+        deactivate_weight: bool = False
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Computes the loss
+
+        Args:
+            pos (torch.Tensor): Positions of the walkers in that batch
+            no_grad (bool, optional): Computes the gradient of the loss 
+                                      (default: {False})
+            deactivate_weight (bool, optional): Deactivates the weight computation 
+                                               (default: {False})
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: Value of the loss, local energies
+        """
+
+        # check if grads are requested
+        with self.get_grad_mode(no_grad):
+            # compute local eneergies
+            local_energies = self.wf.local_energy(pos)
+
+            # mask the energies if necessary
+            mask = self.get_clipping_mask(local_energies)
+
+            # sampling_weight
+            weight = self.get_sampling_weights(pos, deactivate_weight)
+
+            # compute the loss
+            loss = self.loss_fn((weight * local_energies)[mask])
+
+        return loss, local_energies
+
+    @staticmethod
+    def get_grad_mode(no_grad: bool) -> ContextManager:
+        """Returns a context manager to enable or disable gradient computation.
+
+        Args:
+            no_grad (bool): Whether to disable gradient computation.
+
+        Returns:
+            typing.ContextManager: A context manager to disable or enable gradient computation.
+        """
+        return torch.no_grad() if no_grad else torch.enable_grad()
+
+    def get_clipping_mask(self, local_energies: torch.Tensor) -> torch.Tensor:
+        """Computes the clipping mask.
+
+        Args:
+            local_energies (torch.Tensor): Values of the local energies.
+
+        Returns:
+            torch.Tensor: A boolean tensor representing the clipping mask.
+        """
+        if self.clip:
+            median = torch.median(local_energies)
+            std = torch.std(local_energies)
+            zscore = torch.abs((local_energies - median) / std)
+            mask = zscore < self.clip_num_std
+        else:
+            mask = torch.ones_like(local_energies).type(torch.bool)
+
+        return mask
+
+    def get_sampling_weights(
+        self, pos: torch.Tensor, deactivate_weight: bool
+    ) -> torch.Tensor:
+        """Get the weight needed when resampling is not
+        done at every step
+
+        Args:
+            pos (torch.Tensor): Positions of the walkers
+            deactivate_weight (bool): Deactivate the computation of the weight
+
+        Returns:
+            torch.Tensor: The weight to apply to the local energy
+        """
+
+        local_use_weight = self.use_weight * (not deactivate_weight)
+
+        if local_use_weight:
+            # computes the weights
+            self.weight["psi"] = self.wf(pos)
+
+            # if we just resampled store psi and all w=1
+            if self.weight["psi0"] is None:
+                self.weight["psi0"] = self.weight["psi"].detach().clone()
+                w = torch.ones_like(self.weight["psi"])
+
+            # otherwise compute ration of psi
+            else:
+                w = (self.weight["psi"] / self.weight["psi0"]) ** 2
+                w /= w.sum()  # should we multiply by the number of elements ?
+
+            return w
+
+        else:
+            return torch.tensor(1.0)
\ No newline at end of file
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 5b7f92c0..01ca123d 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -1,20 +1,28 @@
 from copy import deepcopy
 from time import time
-
+from tqdm import tqdm
+from types import SimpleNamespace
+from typing import Optional, Dict, Union, List, Tuple, Any
 import torch
-from torch.utils.data import DataLoader
-from qmctorch.utils import (DataSet, Loss,
-                            OrthoReg, add_group_attr,
-                            dump_to_hdf5)
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
+from ..utils import  add_group_attr, dump_to_hdf5, DataLoader
+from qmctorch.utils import add_group_attr, dump_to_hdf5, DataLoader
 
 from .. import log
 from .solver_base import SolverBase
-
+from .loss import Loss
 
 class Solver(SolverBase):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        wf: Optional[WaveFunction] = None,
+        sampler: Optional[SamplerBase] = None,
+        optimizer: Optional[torch.optim.Optimizer] = None,
+        scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+        output: Optional[str] = None,
+        rank: int = 0,
+    ) -> None:
         """Basic QMC solver
 
         Args:
@@ -25,28 +33,37 @@ def __init__(self, wf=None, sampler=None, optimizer=None,
             output (str, optional): hdf5 filename. Defaults to None.
             rank (int, optional): rank of he process. Defaults to 0.
         """
-        SolverBase.__init__(self, wf, sampler,
-                            optimizer, scheduler, output, rank)
+        SolverBase.__init__(self, wf, sampler, optimizer, scheduler, output, rank)
 
         self.set_params_requires_grad()
 
-        self.configure(track=['local_energy'], freeze=None,
-                       loss='energy', grad='manual',
-                       ortho_mo=False, clip_loss=False,
-                       resampling={'mode': 'update',
-                                   'resample_every': 1,
-                                   'nstep_update': 25})
-
-    def configure(self, track=None, freeze=None,
-                  loss=None, grad=None,
-                  ortho_mo=None, clip_loss=False,
-                  resampling=None):
+        self.configure(
+            track=["local_energy"],
+            freeze=None,
+            loss="energy",
+            grad="manual",
+            ortho_mo=False,
+            clip_loss=False,
+            resampling={"mode": "update", "resample_every": 1, "nstep_update": 25},
+        )
+
+    def configure(
+        self,
+        track: Optional[List[str]] = None,
+        freeze: Optional[List[torch.nn.Parameter]] = None,
+        loss: Optional[str] = None,
+        grad: Optional[str] = None,
+        ortho_mo: Optional[bool] = None,
+        clip_loss: bool = False,
+        clip_threshold: int = 5,
+        resampling: Optional[Dict[str, Any]] = None,
+    ) -> None:
         """Configure the solver
 
         Args:
             track (list, optional): list of observable to track. Defaults to ['local_energy'].
-            freeze ([type], optional): list of parameters to freeze. Defaults to None.
-            loss(str, optional): merhod to compute the loss: variance or energy.
+            freeze (list, optional): list of parameters to freeze. Defaults to None.
+            loss (str, optional): method to compute the loss: variance or energy.
                                   Defaults to 'energy'.
             grad (str, optional): method to compute the gradients: 'auto' or 'manual'.
                                   Defaults to 'auto'.
@@ -55,6 +72,7 @@ def configure(self, track=None, freeze=None,
             clip_loss (bool, optional): Clip the loss values at +/- X std. X defined in Loss
                                         as clip_num_std (default 5)
                                         Defaults to False.
+            resampling (dict, optional): resampling options.
         """
 
         # set the parameters we want to optimize/freeze
@@ -70,8 +88,9 @@ def configure(self, track=None, freeze=None,
         if grad is not None:
             self.grad_method = grad
             self.evaluate_gradient = {
-                'auto': self.evaluate_grad_auto,
-                'manual': self.evaluate_grad_manual}[grad]
+                "auto": self.evaluate_grad_auto,
+                "manual": self.evaluate_grad_manual,
+            }[grad]
 
         # resampling of the wave function
         if resampling is not None:
@@ -79,16 +98,17 @@ def configure(self, track=None, freeze=None,
 
         # get the loss
         if loss is not None:
-            self.loss = Loss(self.wf, method=loss, clip=clip_loss)
-            self.loss.use_weight = (
-                self.resampling_options.resample_every > 1)
+            self.loss = Loss(self.wf, method=loss, clip=clip_loss, clip_threshold=clip_threshold)
+            self.loss.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
-        if ortho_mo is not None:
-            self.ortho_mo = ortho_mo
-            self.ortho_loss = OrthoReg()
+        self.ortho_mo = ortho_mo
+        if self.ortho_mo is True:
+            log.warning("Orthogonalization of the MO coeffs via loss penalty is deprecated")
 
-    def set_params_requires_grad(self, wf_params=True, geo_params=False):
+    def set_params_requires_grad(self, 
+                                 wf_params: Optional[bool] = True, 
+                                 geo_params: Optional[bool] = False):
         """Configure parameters for wf opt."""
 
         # opt all wf parameters
@@ -100,14 +120,15 @@ def set_params_requires_grad(self, wf_params=True, geo_params=False):
 
         self.wf.fc.weight.requires_grad = wf_params
 
-        if hasattr(self.wf, 'jastrow'):
-            for param in self.wf.jastrow.parameters():
-                param.requires_grad = wf_params
+        if hasattr(self.wf, "jastrow"):
+            if self.wf.jastrow is not None:
+                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
 
-    def freeze_parameters(self, freeze):
+    def freeze_parameters(self, freeze: List[str]) -> None:
         """Freeze the optimization of specified params.
 
         Args:
@@ -118,121 +139,55 @@ def freeze_parameters(self, freeze):
                 freeze = [freeze]
 
             for name in freeze:
-                if name.lower() == 'ci':
+                if name.lower() == "ci":
                     self.wf.fc.weight.requires_grad = False
 
-                elif name.lower() == 'mo':
+                elif name.lower() == "mo":
                     for param in self.wf.mo.parameters():
                         param.requires_grad = False
 
-                elif name.lower() == 'ao':
+                elif name.lower() == "ao":
                     self.wf.ao.bas_exp.requires_grad = False
                     self.wf.ao.bas_coeffs.requires_grad = False
 
-                elif name.lower() == 'jastrow':
+                elif name.lower() == "jastrow":
                     for param in self.wf.jastrow.parameters():
                         param.requires_grad = False
 
+                elif name.lower() == "backflow":
+                    for param in self.wf.ao.backflow_trans.parameters():
+                        param.requires_grad = False
+
                 else:
-                    opt_freeze = ['ci', 'mo', 'ao', 'jastrow']
-                    raise ValueError(
-                        'Valid arguments for freeze are :', opt_freeze)
+                    opt_freeze = ["ci", "mo", "ao", "jastrow", "backflow"]
+                    raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
-    def save_sampling_parameters(self, pos):
-        """ save the sampling params."""
+    def save_sampling_parameters(self) -> None:
+        """save the sampling params."""
         self.sampler._nstep_save = self.sampler.nstep
         self.sampler._ntherm_save = self.sampler.ntherm
-        self.sampler._nwalker_save = self.sampler.walkers.nwalkers
+        # self.sampler._nwalker_save = self.sampler.walkers.nwalkers
 
-        if self.resampling_options.mode == 'update':
-            self.sampler.ntherm = -1
+        if self.resampling_options.mode == "update":
+            self.sampler.ntherm = self.resampling_options.ntherm_update
             self.sampler.nstep = self.resampling_options.nstep_update
-            self.sampler.walkers.nwalkers = pos.shape[0]
-            self.sampler.nwalkers = pos.shape[0]
+            # self.sampler.walkers.nwalkers = pos.shape[0]
 
-    def restore_sampling_parameters(self):
+    def restore_sampling_parameters(self) -> None:
         """restore sampling params to their original values."""
         self.sampler.nstep = self.sampler._nstep_save
         self.sampler.ntherm = self.sampler._ntherm_save
-        self.sampler.walkers.nwalkers = self.sampler._nwalker_save
-        self.sampler.nwalkers = self.sampler._nwalker_save
-
-    def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
-                nepoch_wf_init=100, nepoch_wf_update=50,
-                hdf5_group='geo_opt', chkpt_every=None, tqdm=False):
-        """optimize the geometry of the molecule
-
-        Args:
-            nepoch (int): Number of optimziation step
-            batchsize (int, optional): Number of sample in a mini batch.
-                                       If None, all samples are used.
-                                       Defaults to Never.
-            hdf5_group (str, optional): name of the hdf5 group where to store the data.
-                                        Defaults to 'geo_opt'.
-            chkpt_every (int, optional): save a checkpoint every every iteration.
-                                         Defaults to half the number of epoch
-        """
-
-        # save the optimizer used for the wf params
-        opt_wf = deepcopy(self.opt)
-        opt_wf.lpos_needed = self.opt.lpos_needed
-
-        # create the optmizier for the geo opt
-        opt_geo = torch.optim.SGD(self.wf.parameters(), lr=geo_lr)
-        opt_geo.lpos_needed = False
-
-        # save the grad method
-        eval_grad_wf = self.evaluate_gradient
-
-        # log data
-        self.prepare_optimization(batchsize, None, tqdm)
-        self.log_data_opt(nepoch, 'geometry optimization')
-
-        # init the traj
-        xyz = [self.wf.geometry(None)]
-
-        # initial wf optimization
-        self.set_params_requires_grad(wf_params=True,
-                                      geo_params=False)
-        self.freeze_parameters(self.freeze_params_list)
-        self.run_epochs(nepoch_wf_init)
-
-        # iterations over geo optim
-        for n in range(nepoch):
-
-            # make one step geo optim
-            self.set_params_requires_grad(wf_params=False,
-                                          geo_params=True)
-            self.opt = opt_geo
-            self.evaluate_gradient = self.evaluate_grad_auto
-            self.run_epochs(1)
-            xyz.append(self.wf.geometry(None))
-
-            # make a few wf optim
-            self.set_params_requires_grad(wf_params=True,
-                                          geo_params=False)
-            self.freeze_parameters(self.freeze_params_list)
-            self.opt = opt_wf
-            self.evaluate_gradient = eval_grad_wf
-
-            cumulative_loss = self.run_epochs(nepoch_wf_update)
-
-            # save checkpoint file
-            if chkpt_every is not None:
-                if (n > 0) and (n % chkpt_every == 0):
-                    self.save_checkpoint(n, cumulative_loss)
-
-        # restore the sampler number of step
-        self.restore_sampling_parameters()
+        # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
-        # dump
-        self.observable.geometry = xyz
-        self.save_data(hdf5_group)
-
-        return self.observable
 
-    def run(self, nepoch, batchsize=None,
-            hdf5_group='wf_opt', chkpt_every=None, tqdm=False):
+    def run(
+        self, 
+        nepoch: int, 
+        batchsize : Optional[int] = None, 
+        hdf5_group: Optional[str] = "wf_opt", 
+        chkpt_every: Optional[int] = None, 
+        tqdm: Optional[bool] = False
+    ) -> SimpleNamespace:
         """Run a wave function optimization
 
         Args:
@@ -245,10 +200,9 @@ def run(self, nepoch, batchsize=None,
             chkpt_every (int, optional): save a checkpoint every every iteration.
                                          Defaults to half the number of epoch
         """
-
         # prepare the optimization
         self.prepare_optimization(batchsize, chkpt_every, tqdm)
-        self.log_data_opt(nepoch, 'wave function optimization')
+        self.log_data_opt(nepoch, "wave function optimization")
 
         # run the epochs
         self.run_epochs(nepoch)
@@ -261,13 +215,15 @@ def run(self, nepoch, batchsize=None,
 
         return self.observable
 
-    def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
+    def prepare_optimization(self, batchsize: int, chkpt_every: int , tqdm: Optional[bool] = False):
         """Prepare the optimization process
 
         Args:
             batchsize (int or None): batchsize
             chkpt_every (int or none): save a chkpt file every
         """
+        log.info("  Initial Sampling    :")
+        tstart = time()
 
         # sample the wave function
         pos = self.sampler(self.wf.pdf, with_tqdm=tqdm)
@@ -277,12 +233,10 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
             batchsize = len(pos)
 
         # change the number of steps/walker size
-        self.save_sampling_parameters(pos)
+        self.save_sampling_parameters()
 
         # create the data loader
-        self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(
-            self.dataset, batch_size=batchsize)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -290,7 +244,9 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         # chkpt
         self.chkpt_every = chkpt_every
 
-    def save_data(self, hdf5_group):
+        log.info("  done in %1.2f sec." % (time() - tstart))
+
+    def save_data(self, hdf5_group: str):
         """Save the data to hdf5.
 
         Args:
@@ -298,33 +254,50 @@ def save_data(self, hdf5_group):
         """
         self.observable.models.last = dict(self.wf.state_dict())
 
-        hdf5_group = dump_to_hdf5(
-            self.observable, self.hdf5file, hdf5_group)
+        hdf5_group = dump_to_hdf5(self.observable, self.hdf5file, hdf5_group)
 
-        add_group_attr(self.hdf5file, hdf5_group, {'type': 'opt'})
+        add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
-    def run_epochs(self, nepoch):
+    def run_epochs(self, nepoch: int, 
+                   with_tqdm: Optional[bool] = False, 
+                   verbose: Optional[bool] = True) -> float :
         """Run a certain number of epochs
 
         Args:
             nepoch (int): number of epoch to run
         """
 
+        if with_tqdm and verbose:
+            raise ValueError("tqdm and verbose are mutually exclusive")
+
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
+        min_loss = 0  # this is set at n=0
+        
+        # the range 
+        rng = tqdm(
+            range(nepoch),
+            desc="INFO:QMCTorch|  Optimization",
+            disable=not with_tqdm,
+        )
 
         # loop over the epoch
-        for n in range(nepoch):
+        for n in rng:
 
-            tstart = time()
-            log.info('')
-            log.info('  epoch %d' % n)
+            if verbose:
+                tstart = time()
+                log.info("")
+                log.info(
+                    "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
+                )
 
+            # reset the gradients and loss
             cumulative_loss = 0
+            self.opt.zero_grad()
+            self.wf.zero_grad()
 
             # loop over the batches
             for ibatch, data in enumerate(self.dataloader):
-
                 # port data to device
                 lpos = data.to(self.device)
 
@@ -334,41 +307,41 @@ def run_epochs(self, nepoch):
 
                 # check for nan
                 if torch.isnan(eloc).any():
-                    log.info('Error : Nan detected in local energy')
+                    log.info("Error : Nan detected in local energy")
                     return cumulative_loss
 
-                # optimize the parameters
-                self.optimization_step(lpos)
-
                 # observable
-                self.store_observable(
-                    lpos, local_energy=eloc, ibatch=ibatch)
+                self.store_observable(lpos, local_energy=eloc, ibatch=ibatch)
+
+            # optimize the parameters
+            self.optimization_step(lpos)
 
             # save the model if necessary
             if n == 0 or cumulative_loss < min_loss:
                 min_loss = cumulative_loss
-                self.observable.models.best = dict(
-                    self.wf.state_dict())
+                self.observable.models.best = dict(self.wf.state_dict())
 
             # save checkpoint file
             if self.chkpt_every is not None:
                 if (n > 0) and (n % self.chkpt_every == 0):
                     self.save_checkpoint(n, cumulative_loss)
 
-            self.print_observable(cumulative_loss, verbose=False)
+            if verbose:
+                self.print_observable(cumulative_loss, verbose=False)
 
             # resample the data
-            self.dataset.data = self.resample(n, self.dataset.data)
+            self.dataloader.dataset = self.resample(n, self.dataloader.dataset)
 
             # scheduler step
             if self.scheduler is not None:
                 self.scheduler.step()
 
-            log.info('  epoch done in %1.2f sec.' % (time()-tstart))
+            if verbose:
+                log.info("  epoch done in %1.2f sec." % (time() - tstart))
 
         return cumulative_loss
 
-    def evaluate_grad_auto(self, lpos):
+    def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Evaluate the gradient using automatic differentiation
 
         Args:
@@ -381,18 +354,18 @@ def evaluate_grad_auto(self, lpos):
         # compute the loss
         loss, eloc = self.loss(lpos)
 
-        # add mo orthogonalization if required
-        if self.wf.mo.weight.requires_grad and self.ortho_mo:
-            loss += self.ortho_loss(self.wf.mo.weight)
-
         # compute local gradients
-        self.opt.zero_grad()
         loss.backward()
 
         return loss, eloc
 
-    def evaluate_grad_manual(self, lpos):
+    def evaluate_grad_manual(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Evaluate the gradient using low variance expression
+        WARNING : This method is not valid to compute forces
+        as it does not include derivative of the hamiltonian 
+        wrt atomic positions 
+ 
+        https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
 
         Args:
             lpos ([type]): [description]
@@ -406,61 +379,252 @@ def evaluate_grad_manual(self, lpos):
 
         # determine if we need the grad of eloc
         no_grad_eloc = True
-        if self.wf.kinetic_method == 'auto':
+        if self.wf.kinetic_method == "auto":
             no_grad_eloc = False
 
         if self.wf.jastrow.requires_autograd:
             no_grad_eloc = False
 
-        if self.loss.method in ['energy', 'weighted-energy']:
-
+        if self.loss.method in ["energy", "weighted-energy"]:
             # Get the gradient of the total energy
             # dE/dk = < (dpsi/dk)/psi (E_L - <E_L >) >
-            
+
+            # compute local energy
+            with self.loss.get_grad_mode(no_grad_eloc):
+                eloc = self.wf.local_energy(lpos)            
+
+            # compute the wf values
+            psi = self.wf(lpos)
+            norm = 1.0 / len(psi)
+
+            # evaluate the prefactor of the grads
+            weight = eloc.clone()
+            weight -= torch.mean(eloc)
+            weight /= psi.clone()
+            weight *= 2.0 * norm
+
+            # clip the values
+            clip_mask = self.loss.get_clipping_mask(eloc)
+            psi = psi[clip_mask]
+            weight = weight[clip_mask]
+
+            # compute the gradients
+            psi.backward(weight)
+
+            return torch.mean(eloc), eloc
+
+        else:
+            raise ValueError("Manual gradient only for energy minimization")
+        
+    def evaluate_grad_manual_2(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Evaluate the gradient using low variance expression
+        WARNING : This method is not valid to compute forces
+        as it does not include derivative of the hamiltonian 
+        wrt atomic positions
+
+        https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
+
+        Args:
+            lpos ([type]): [description]
+
+        Args:
+            lpos (torch.tensor): sampling points
+
+        Returns:
+            tuple: loss values and local energies
+        """
+
+        # determine if we need the grad of eloc
+        no_grad_eloc = True
+        if self.wf.kinetic_method == "auto":
+            no_grad_eloc = False
+
+        if self.wf.jastrow.requires_autograd:
+            no_grad_eloc = False
+
+        if self.loss.method in ["energy", "weighted-energy"]:
+            # Get the gradient of the total energy
+            # dE/dk = 2 [ < (dpsi/dk) E_L/psi >  - < (dpsi/dk) / psi > <E_L > ]
+            # https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
 
             # compute local energy and wf values
-            _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
+            eloc_mean, eloc = self.loss(lpos, no_grad=no_grad_eloc)
             psi = self.wf(lpos)
-            norm = 1. / len(psi)
+            norm = 2.0 / len(psi)
+
+            weight1 = norm * eloc/psi.detach().clone()
+            weight2 = -norm * eloc_mean/psi.detach().clone()
+
+            # clip the values
+            clip_mask = self.loss.get_clipping_mask(eloc)
+            psi = psi[clip_mask]
+            weight1 = weight1[clip_mask]
+            weight2 = weight2[clip_mask]
+
+
+            psi.backward(weight1,retain_graph=True) 
+            psi.backward(weight2)
+
+            return torch.mean(eloc), eloc
+
+        else:
+            raise ValueError("Manual gradient only for energy minimization")
+
+    def evaluate_grad_manual_3(self, lpos: torch.tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Evaluate the gradient using low variance expression
+        WARNING : This method is not valid to compute forces
+        as it does not include derivative of the hamiltonian 
+        wrt atomic positions 
+ 
+        https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
+
+        Args:
+            lpos ([type]): [description]
+
+        Args:
+            lpos (torch.tensor): sampling points
+
+        Returns:
+            tuple: loss values and local energies
+        """
+
+        # determine if we need the grad of eloc
+        no_grad_eloc = True
+        if self.wf.kinetic_method == "auto":
+            no_grad_eloc = False
+
+        if self.wf.jastrow.requires_autograd:
+            no_grad_eloc = False
+
+        if self.loss.method in ["energy", "weighted-energy"]:
+            # Get the gradient of the total energy
+            # dE/dk = <  (E_L - <E_L >) d[ln(abs(psi))] / dk) >
+
+            # compute local energy
+            with self.loss.get_grad_mode(no_grad_eloc):
+                eloc = self.wf.local_energy(lpos)            
+
+            # compute the wf values
+            psi = torch.log(torch.abs(self.wf(lpos)))
+            norm = 1.0 / len(psi)
 
             # evaluate the prefactor of the grads
             weight = eloc.clone()
             weight -= torch.mean(eloc)
-            weight /= psi
-            weight *= 2.
-            weight *= norm
+            weight *= 2.0 * norm
+
+            # clip the values
+            clip_mask = self.loss.get_clipping_mask(eloc)
+            psi = psi[clip_mask]
+            weight = weight[clip_mask]
 
             # compute the gradients
-            self.opt.zero_grad()
             psi.backward(weight)
 
             return torch.mean(eloc), eloc
 
         else:
-            raise ValueError(
-                'Manual gradient only for energy minimization')
+            raise ValueError("Manual gradient only for energy minimization")
+
+
+    def compute_forces(self, lpos: torch.tensor, batch_size: int = None, clip: int = None) -> torch.tensor:
+        r"""
+        Compute the forces using automatic differentation and stable estimator
+
+        ..math::
+            F = -\\langle \\nabla_\\alpha E_L(R) + (E_L(R) - E) \\nabla)\\alpha |\Psi(R)|^2 \\rangle
+
+        see e.g. https://arxiv.org/abs/2404.09755
+
+        Args:
+            lpos (torch.tensor): sampling points
+            batch_size (int): the size of the batch to use for the automatic differentiation
+            clip (int): the number of decimal places to clip the sampling points
+
+        Returns:
+            torch.tensor: the numerical forces
+
+        """
+
+        def get_clipping_mask(values: torch.tensor, clip: int) -> torch.tensor:
+            """
+            Compute a mask to clip the values based on their zscore
+
+            Parameters
+            ----------
+            values : torch.tensor
+                the values to clip
+            clip : int
+                the number of decimal places to clip the values
+
+            Returns
+            -------
+            mask : torch.tensor
+                the mask to clip the values
+            """
+            if clip is not None:
+                median = torch.median(values)
+                std = torch.std(values)
+                zscore = torch.abs((values - median) / std)    
+                mask = zscore < clip
+            else:
+                mask = torch.ones_like(values).type(torch.bool)
+
+            return mask
+    
+        original_requires_grad = self.wf.ao.atom_coords.requires_grad
+        if not original_requires_grad:
+            self.wf.ao.atom_coords.requires_grad = True
+
+        if batch_size is None:
+            batch_size = lpos.shape[0]
+        nbatch = lpos.shape[0]//batch_size
+
+        forces = torch.zeros_like(self.wf.ao.atom_coords)
+
+        for ibatch in range(nbatch):
+
+            # get the batch
+            idx_start = ibatch*batch_size
+            idx_end = (ibatch+1)*batch_size
+            if idx_end > lpos.shape[0]:
+                idx_end = lpos.shape[0]
+            lpos_batch = lpos[idx_start:idx_end]
+
+            # compute the local energy and its gradient
+            local_energy = self.wf.local_energy(lpos_batch)
+            clip_mask = get_clipping_mask(local_energy, clip)
+            grad_eloc =  torch.autograd.grad(local_energy, self.wf.ao.atom_coords, grad_outputs=clip_mask)[0]
+
+            # compute the log density and its gradient
+            wf_val = self.wf.pdf(lpos_batch)
+            proba = torch.log(wf_val)
+            grad_outputs = ((local_energy-local_energy.mean()) * clip_mask).squeeze()
+            grad_proba = torch.autograd.grad(proba, self.wf.ao.atom_coords, grad_outputs=grad_outputs)[0]
+        
+            # accumulate in the force
+            forces += 1./batch_size * (grad_eloc + grad_proba)
+
+        if not original_requires_grad:
+            self.wf.ao.atom_coords.requires_grad = False
+
+        return forces
+
 
     def log_data_opt(self, nepoch, task):
         """Log data for the optimization."""
-        log.info('')
-        log.info('  Optimization')
-        log.info('  Task                :', task)
-        log.info(
-            '  Number Parameters   : {0}', self.wf.get_number_parameters())
-        log.info('  Number of epoch     : {0}', nepoch)
-        log.info(
-            '  Batch size          : {0}', self.sampler.get_sampling_size())
-        log.info('  Loss function       : {0}', self.loss.method)
-        log.info('  Clip Loss           : {0}', self.loss.clip)
-        log.info('  Gradients           : {0}', self.grad_method)
-        log.info(
-            '  Resampling mode     : {0}', self.resampling_options.mode)
-        log.info(
-            '  Resampling every    : {0}', self.resampling_options.resample_every)
-        log.info(
-            '  Resampling steps    : {0}', self.resampling_options.nstep_update)
-        log.info(
-            '  Output file         : {0}', self.hdf5file)
-        log.info(
-            '  Checkpoint every    : {0}', self.chkpt_every)
-        log.info('')
+        log.info("")
+        log.info("  Optimization")
+        log.info("  Task                :", task)
+        log.info("  Number Parameters   : {0}", self.wf.get_number_parameters())
+        log.info("  Number of epoch     : {0}", nepoch)
+        log.info("  Batch size          : {0}", self.sampler.get_sampling_size())
+        log.info("  Loss function       : {0}", self.loss.method)
+        log.info("  Clip Loss           : {0}", self.loss.clip)
+        log.info("  Gradients           : {0}", self.grad_method)
+        log.info("  Resampling mode     : {0}", self.resampling_options.mode)
+        log.info("  Resampling every    : {0}", self.resampling_options.resample_every)
+        log.info("  Resampling steps    : {0}", self.resampling_options.nstep_update)
+        log.info("  Output file         : {0}", self.hdf5file)
+        log.info("  Checkpoint every    : {0}", self.chkpt_every)
+        log.info("")
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 7d3bbf3f..e9fe7a3a 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,4 +1,7 @@
 from types import SimpleNamespace
+from typing import Optional, Dict, Union, List, Tuple, Any
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
 import os
 import numpy as np
 import torch
@@ -6,20 +9,25 @@
 
 from .. import log
 from ..utils import add_group_attr, dump_to_hdf5
-
+from ..utils import get_git_tag
 
 class SolverBase:
-
-    def __init__(self, wf=None, sampler=None,
-                 optimizer=None, scheduler=None,
-                 output=None, rank=0):
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        wf: Optional[WaveFunction] = None,
+        sampler: Optional[SamplerBase] = None,
+        optimizer: Optional[torch.optim.Optimizer] = None,
+        scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+        output: Optional[str] = None,
+        rank: int = 0,
+    ) -> None:
         """Base Class for QMC solver
 
         Args:
             wf (qmctorch.WaveFunction, optional): wave function. Defaults to None.
             sampler (qmctorch.sampler, optional): Sampler. Defaults to None.
-            optimizer (torch.optim, optional): optimizer. Defaults to None.
-            scheduler (torch.optim, optional): scheduler. Defaults to None.
+            optimizer (torch.optim.Optimizer, optional): optimizer. Defaults to None.
+            scheduler (torch.optim.lr_scheduler._LRScheduler, optional): scheduler. Defaults to None.
             output (str, optional): hdf5 filename. Defaults to None.
             rank (int, optional): rank of he process. Defaults to 0.
         """
@@ -29,7 +37,8 @@ def __init__(self, wf=None, sampler=None,
         self.opt = optimizer
         self.scheduler = scheduler
         self.cuda = False
-        self.device = torch.device('cpu')
+        self.device: torch.device = torch.device("cpu")
+        self.qmctorch_version: str = get_git_tag()
 
         # member defined in the child and or method
         self.dataloader = None
@@ -37,54 +46,70 @@ def __init__(self, wf=None, sampler=None,
         self.obs_dict = None
 
         # if pos are needed for the optimizer (obsolete ?)
-        if self.opt is not None and 'lpos_needed' not in self.opt.__dict__.keys():
+        if self.opt is not None and "lpos_needed" not in self.opt.__dict__.keys():
             self.opt.lpos_needed = False
 
         # distributed model
-        self.save_model = 'model.pth'
+        self.save_model: str = "model.pth"
 
         # handles GPU availability
         if self.wf.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
             self.sampler.cuda = True
             self.sampler.walkers.cuda = True
         else:
-            self.device = torch.device('cpu')
+            self.device = torch.device("cpu")
 
-        self.hdf5file = output
+        self.hdf5file: str = output
         if output is None:
-            basename = os.path.basename(
-                self.wf.mol.hdf5file).split('.')[0]
-            self.hdf5file = basename + '_QMCTorch.hdf5'
+            basename: str = os.path.basename(self.wf.mol.hdf5file).split(".")[0]
+            self.hdf5file = basename + "_QMCTorch.hdf5"
+
 
         if rank == 0:
+            if os.path.isfile(self.hdf5file):
+                os.remove(self.hdf5file)
             dump_to_hdf5(self, self.hdf5file)
 
         self.log_data()
 
-    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25):
+    def configure_resampling(  # pylint: disable=too-many-arguments
+        self,
+        mode: str ="update",
+        resample_every: int =1,
+        nstep_update: int = 25,
+        ntherm_update: int = -1,
+        increment: Dict = {"every": None, "factor": None},
+    ):
         """Configure the resampling
 
         Args:
             mode (str, optional): method to resample : 'full', 'update', 'never'
-                                  Defaults to 'update'.
+                                  Defaultsr to 'update'.
             resample_every (int, optional): Number of optimization steps between resampling
                                  Defaults to 1.
             nstep_update (int, optional): Number of MC steps in update mode.
                                           Defaults to 25.
+            ntherm_update (int, oprrtional): Number of MC steps to thermalize the new sampling.
+                                          Defaults to -1.
+            increment (dict, optional): dict containing the option to increase the sampling space
+                                        every (int) : increment the sampling space every n optimization step
+                                        factor (int) : increment with factor x nwalkers points
+
         """
 
         self.resampling_options = SimpleNamespace()
-        valid_mode = ['never', 'full', 'update']
+        valid_mode = ["never", "full", "update"]
         if mode not in valid_mode:
-            raise ValueError(
-                mode, 'not a valid update method : ', valid_mode)
+            raise ValueError(mode, "not a valid update method : ", valid_mode)
 
         self.resampling_options.mode = mode
         self.resampling_options.resample_every = resample_every
+        self.resampling_options.ntherm_update = ntherm_update
         self.resampling_options.nstep_update = nstep_update
+        self.resampling_options.increment = increment
 
-    def track_observable(self, obs_name):
+    def track_observable(self, obs_name: Union[str, List[str]]):
         """define the observalbe we want to track
 
         Args:
@@ -97,102 +122,112 @@ def track_observable(self, obs_name):
             obs_name = list(obs_name)
 
         # sanity check
-        valid_obs_name = ['energy', 'local_energy',
-                          'geometry', 'parameters', 'gradients']
+        valid_obs_name = [
+            "energy",
+            "local_energy",
+            "geometry",
+            "parameters",
+            "gradients",
+        ]
         for name in obs_name:
             if name in valid_obs_name:
                 continue
             elif hasattr(self.wf, name):
                 continue
             else:
-                log.info(
-                    '   Error : Observable %s not recognized' % name)
-                log.info('         : Possible observable')
+                log.info("   Error : Observable %s not recognized" % name)
+                log.info("         : Possible observable")
                 for n in valid_obs_name:
-                    log.info('         :  - %s' % n)
-                log.info(
-                    '         :  - or any method of the wave function')
-                raise ValueError('Observable not recognized')
+                    log.info("         :  - %s" % n)
+                log.info("         :  - or any method of the wave function")
+                raise ValueError("Observable not recognized")
 
         # reset the Namesapce
         self.observable = SimpleNamespace()
-
+        self.observable.qmctorch_version = self.qmctorch_version
+        
         # add the energy of the sytem
-        if 'energy' not in obs_name:
-            obs_name += ['energy']
+        if "energy" not in obs_name:
+            obs_name += ["energy"]
 
         # add the geometry of the system
-        if 'geometry' not in obs_name:
-            obs_name += ['geometry']
+        if "geometry" not in obs_name:
+            obs_name += ["geometry"]
 
         for k in obs_name:
-
-            if k == 'parameters':
-                for key, p in zip(self.wf.state_dict().keys(),
-                                  self.wf.parameters()):
+            if k == "parameters":
+                # for key, p in zip(self.wf.state_dict().keys(), self.wf.parameters()):
+                for key, p in self.wf.named_parameters():
                     if p.requires_grad:
                         self.observable.__setattr__(key, [])
 
-            elif k == 'gradients':
-                for key, p in zip(self.wf.state_dict().keys(),
-                                  self.wf.parameters()):
+            elif k == "gradients":
+                # for key, p in zip(self.wf.state_dict().keys(), self.wf.parameters()):
+                for key, p in self.wf.named_parameters():
                     if p.requires_grad:
-                        self.observable.__setattr__(key+'.grad', [])
+                        self.observable.__setattr__(key + ".grad", [])
 
             else:
                 self.observable.__setattr__(k, [])
 
         self.observable.models = SimpleNamespace()
 
-    def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
+    def store_observable(self, pos: torch.tensor, 
+                         local_energy: Optional[torch.tensor] = None, 
+                         ibatch: Optional[int] = None, 
+                         **kwargs):
         """store observale in the dictionary
 
         Args:
-            obs_dict (dict): dictionary of the observalbe
             pos (torch.tensor): positions of th walkers
             local_energy (torch.tensor, optional): precomputed values of the local
                                            energy. Defaults to None
             ibatch (int): index of the current batch. Defaults to None
         """
 
-        if self.wf.cuda and pos.device.type == 'cpu':
+        if self.wf.cuda and pos.device.type == "cpu":
             pos = pos.to(self.device)
 
         for obs in self.observable.__dict__.keys():
-
             # store the energy
-            if obs == 'energy' and local_energy is not None:
+            if obs == "energy":
+                if local_energy is None:
+                    local_energy = self.wf.local_energy(pos)
+
                 data = local_energy.cpu().detach().numpy()
+
                 if (ibatch is None) or (ibatch == 0):
-                    self.observable.energy.append(np.mean(data))
+                    self.observable.energy.append(np.mean(data).item())
                 else:
-                    self.observable.energy[-1] *= ibatch/(ibatch+1)
-                    self.observable.energy[-1] += np.mean(
-                        data)/(ibatch+1)
+                    self.observable.energy[-1] *= ibatch / (ibatch + 1)
+                    self.observable.energy[-1] += np.mean(data).item() / (ibatch + 1)
 
             # store local energy
-            elif obs == 'local_energy' and local_energy is not None:
+            elif obs == "local_energy" and local_energy is not None:
                 data = local_energy.cpu().detach().numpy()
                 if (ibatch is None) or (ibatch == 0):
                     self.observable.local_energy.append(data)
                 else:
                     self.observable.local_energy[-1] = np.append(
-                        self.observable.local_energy[-1], data)
+                        self.observable.local_energy[-1], data
+                    )
 
             # store variational parameter
             elif obs in self.wf.state_dict():
-
                 p = self.wf.state_dict()[obs].clone()
-                self.observable.__getattribute__(
-                    obs).append(p.data.cpu().detach().numpy())
+                self.observable.__getattribute__(obs).append(
+                    p.data.cpu().detach().numpy()
+                )
 
-                if obs+'.grad' in self.observable.__dict__.keys():
+                if obs + ".grad" in self.observable.__dict__.keys():
                     if p.grad is not None:
-                        self.observable.__getattribute__(obs +
-                                                         '.grad').append(p.grad.cpu().numpy())
+                        self.observable.__getattribute__(obs + ".grad").append(
+                            p.grad.cpu().numpy()
+                        )
                     else:
-                        self.observable.__getattribute__(obs +
-                                                         '.grad').append(torch.zeros_like(p.data).cpu().numpy())
+                        self.observable.__getattribute__(obs + ".grad").append(
+                            torch.zeros_like(p.data).cpu().numpy()
+                        )
 
             # store any other defined method
             elif hasattr(self.wf, obs):
@@ -203,14 +238,13 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
                 if isinstance(data, list):
                     data = np.array(data)
                 if (ibatch is None) or (ibatch == 0):
-                    self.observable.__getattribute__(
-                        obs).append(data)
+                    self.observable.__getattribute__(obs).append(data)
                 else:
-                    self.observable.__getattribute__(
-                        obs)[-1] = np.append(self.observable.__getattribute__(
-                            obs)[-1], data)
+                    self.observable.__getattribute__(obs)[-1] = np.append(
+                        self.observable.__getattribute__(obs)[-1], data
+                    )
 
-    def print_observable(self, cumulative_loss, verbose=False):
+    def print_observable(self, cumulative_loss: float, verbose: bool = False):
         """Print the observalbe to csreen
 
         Args:
@@ -219,25 +253,21 @@ def print_observable(self, cumulative_loss, verbose=False):
         """
 
         for k in self.observable.__dict__.keys():
-
-            if k == 'local_energy':
-
+            if k == "local_energy":
                 eloc = self.observable.local_energy[-1]
                 e = np.mean(eloc)
                 v = np.var(eloc)
                 err = np.sqrt(v / len(eloc))
-                log.options(style='percent').info(
-                    '  energy   : %f +/- %f' % (e, err))
-                log.options(style='percent').info(
-                    '  variance : %f' % np.sqrt(v))
+                log.options(style="percent").info("  energy   : %f +/- %f" % (e, err))
+                log.options(style="percent").info("  variance : %f" % np.sqrt(v))
 
             elif verbose:
-                log.options(style='percent').info(
-                    k + ' : ', self.observable.__getattribute__(k)[-1])
-                log.options(style='percent').info(
-                    'loss %f' % (cumulative_loss))
+                log.options(style="percent").info(
+                    k + " : ", self.observable.__getattribute__(k)[-1]
+                )
+                log.options(style="percent").info("loss %f" % (cumulative_loss))
 
-    def resample(self, n, pos):
+    def resample(self, n : int, pos: torch.tensor) -> torch.tensor:
         """Resample the wave function
 
         Args:
@@ -248,32 +278,42 @@ def resample(self, n, pos):
             (torch.tensor): new positions of the walkers
         """
 
-        if self.resampling_options.mode != 'never':
-
+        if self.resampling_options.mode != "never":
             # resample the data
-            if (n % self.resampling_options.resample_every == 0):
-
+            if n % self.resampling_options.resample_every == 0:
                 # make a copy of the pos if we update
-                if self.resampling_options.mode == 'update':
-                    pos = pos.clone().detach().to(self.device)
+                if self.resampling_options.mode == "update":
+                    pos = (pos.clone().detach()[: self.sampler.walkers.nwalkers]).to(
+                        self.device
+                    )
 
                 # start from scratch otherwise
                 else:
                     pos = None
 
+                # potentially increase the number of sampling point
+                if self.resampling_options.increment["every"] is not None:
+                    if n % self.resampling_options.increment["every"] == 0:
+                        self.sampler.nstep += (
+                            self.resampling_options.increment["factor"]
+                            * self.sampler.ndecor
+                        )
+
                 # sample and update the dataset
-                pos = self.sampler(
-                    self.wf.pdf, pos=pos, with_tqdm=False)
-                self.dataloader.dataset.data = pos
+                pos = self.sampler(self.wf.pdf, pos=pos, with_tqdm=False)
+
+                self.dataloader.dataset = pos
 
             # update the weight of the loss if needed
             if self.loss.use_weight:
-                self.loss.weight['psi0'] = None
+                self.loss.weight["psi0"] = None
 
         return pos
 
-    def single_point(self, with_tqdm=True, hdf5_group='single_point'):
-        """Performs a single point calculatin
+    def single_point(self, with_tqdm: Optional[bool] = True, 
+                     batchsize: Optional[int] = None, 
+                     hdf5_group: str = "single_point"):
+        """Performs a single point calculation
 
         Args:
             with_tqdm (bool, optional): use tqdm for samplig. Defaults to True.
@@ -284,66 +324,81 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
             SimpleNamespace: contains the local energy, positions, ...
         """
 
-        log.info('')
-        log.info('  Single Point Calculation : {nw} walkers | {ns} steps',
-                 nw=self.sampler.nwalkers, ns=self.sampler.nstep)
+        log.info("")
+        log.info(
+            "  Single Point Calculation : {nw} walkers | {ns} steps",
+            nw=self.sampler.walkers.nwalkers,
+            ns=self.sampler.nstep,
+        )
 
         # check if we have to compute and store the grads
         grad_mode = torch.no_grad()
-        if self.wf.kinetic == 'auto':
+        if self.wf.kinetic == "auto":
             grad_mode = torch.enable_grad()
 
-        with grad_mode:
+        if self.wf.jastrow.requires_autograd:
+            grad_mode = torch.enable_grad()
 
+        with grad_mode:
             #  get the position and put to gpu if necessary
             pos = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
-            if self.wf.cuda and pos.device.type == 'cpu':
+            if self.wf.cuda and pos.device.type == "cpu":
                 pos = pos.to(self.device)
 
             # compute energy/variance/error
-            el = self.wf.local_energy(pos)
-            e, s, err = torch.mean(el), torch.var(
-                el), self.wf.sampling_error(el)
+            if batchsize is None:
+                eloc = self.wf.local_energy(pos)
+
+            else:
+                nbatch = int(np.ceil(len(pos) / batchsize))
+
+                for ibatch in range(nbatch):
+                    istart = ibatch * batchsize
+                    iend = min((ibatch + 1) * batchsize, len(pos))
+                    if ibatch == 0:
+                        eloc = self.wf.local_energy(pos[istart:iend, :])
+                    else:
+                        eloc = torch.cat(
+                            (eloc, self.wf.local_energy(pos[istart:iend, :]))
+                        )
+
+            e, s, err = torch.mean(eloc), torch.var(eloc), self.wf.sampling_error(eloc)
 
             # print data
-            log.options(style='percent').info(
-                '  Energy   : %f +/- %f' % (e.detach().item(), err.detach().item()))
-            log.options(style='percent').info(
-                '  Variance : %f' % s.detach().item())
+            log.options(style="percent").info(
+                "  Energy   : %f +/- %f" % (e.detach().item(), err.detach().item())
+            )
+            log.options(style="percent").info("  Variance : %f" % s.detach().item())
+            log.options(style="percent").info("  Size     : %d" % len(eloc))
 
             # dump data to hdf5
             obs = SimpleNamespace(
-                pos=pos,
-                local_energy=el,
-                energy=e,
-                variance=s,
-                error=err
+                pos=pos, local_energy=eloc, energy=e, variance=s, error=err
             )
-            dump_to_hdf5(obs,
-                         self.hdf5file,
-                         root_name=hdf5_group)
-            add_group_attr(self.hdf5file, hdf5_group,
-                           {'type': 'single_point'})
+            dump_to_hdf5(obs, self.hdf5file, root_name=hdf5_group)
+            add_group_attr(self.hdf5file, hdf5_group, {"type": "single_point"})
 
         return obs
 
-    def save_checkpoint(self, epoch, loss):
+    def save_checkpoint(self, epoch: int , loss: float):
         """save the model and optimizer state
 
         Args:
             epoch (int): epoch
             loss (float): current value of the loss
-            filename (str): name to save the file
         """
-        filename = 'checkpoint_epoch%d.pth' % epoch
-        torch.save({
-            'epoch': epoch,
-            'model_state_dict': self.wf.state_dict(),
-            'optimzier_state_dict': self.opt.state_dict(),
-            'loss': loss
-        }, filename)
-
-    def load_checkpoint(self, filename):
+        filename = "checkpoint_epoch%d.pth" % epoch
+        torch.save(
+            {
+                "epoch": epoch,
+                "model_state_dict": self.wf.state_dict(),
+                "optimzier_state_dict": self.opt.state_dict(),
+                "loss": loss,
+            },
+            filename,
+        )
+
+    def load_checkpoint(self, filename: str) -> Tuple[int, float]:
         """load a model/optmizer
 
         Args:
@@ -353,13 +408,13 @@ def load_checkpoint(self, filename):
             tuple : epoch number and loss
         """
         data = torch.load(filename)
-        self.wf.load_state_dict(data['model_state_dict'])
-        self.opt.load_state_dict(data['optimzier_state_dict'])
-        epoch = data['epoch']
-        loss = data['loss']
+        self.wf.load_state_dict(data["model_state_dict"])
+        self.opt.load_state_dict(data["optimzier_state_dict"])
+        epoch = data["epoch"]
+        loss = data["loss"]
         return epoch, loss
 
-    def _append_observable(self, key, data):
+    def _append_observable(self, key : str, data: Any):
         """Append a new data point to observable key.
 
         Arguments:
@@ -371,7 +426,10 @@ def _append_observable(self, key, data):
             self.obs_dict[key] = []
         self.obs_dict[key].append(data)
 
-    def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group='sampling_trajectory'):
+    def sampling_traj(self, pos: Optional[torch.tensor] = None, 
+                      with_tqdm: Optional[bool] = True, 
+                      hdf5_group: Optional[str] = "sampling_trajectory"
+                      ) -> torch.tensor:
         """Compute the local energy along a sampling trajectory
 
         Args:
@@ -381,30 +439,30 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group='sampling_trajector
         Returns:
             SimpleNamespace : contains energy/positions/
         """
-        log.info('')
-        log.info('  Sampling trajectory')
+        log.info("")
+        log.info("  Sampling trajectory")
 
         if pos is None:
             pos = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
 
         ndim = pos.shape[-1]
-        p = pos.view(-1, self.sampler.nwalkers, ndim)
+        p = pos.view(-1, self.sampler.walkers.nwalkers, ndim)
+        
         el = []
-        rng = tqdm(p, desc='INFO:QMCTorch|  Energy  ',
-                   disable=not with_tqdm)
+        rng = tqdm(p, desc="INFO:QMCTorch|  Energy  ", disable=not with_tqdm)
         for ip in rng:
+            if self.wf.cuda and ip.device.type == "cpu":
+                ip = ip.to(self.device)
             el.append(self.wf.local_energy(ip).cpu().detach().numpy())
 
         el = np.array(el).squeeze(-1)
         obs = SimpleNamespace(local_energy=np.array(el), pos=pos)
-        dump_to_hdf5(obs,
-                     self.hdf5file, hdf5_group)
+        dump_to_hdf5(obs, self.hdf5file, hdf5_group)
 
-        add_group_attr(self.hdf5file, hdf5_group,
-                       {'type': 'sampling_traj'})
+        add_group_attr(self.hdf5file, hdf5_group, {"type": "sampling_traj"})
         return obs
 
-    def print_parameters(self, grad=False):
+    def print_parameters(self, grad: Optional[bool]=False) -> None:
         """print parameter values
 
         Args:
@@ -417,7 +475,7 @@ def print_parameters(self, grad=False):
                 else:
                     print(p)
 
-    def optimization_step(self, lpos):
+    def optimization_step(self, lpos: torch.tensor) -> None:
         """Performs one optimization step
 
         Arguments:
@@ -429,58 +487,52 @@ def optimization_step(self, lpos):
         else:
             self.opt.step()
 
-    def save_traj(self, fname, obs):
+    def save_traj(self, fname: str, obs: SimpleNamespace):
         """Save trajectory of geo_opt
 
         Args:
             fname (str): file name
         """
-        f = open(fname, 'w')
+        f = open(fname, "w")
         xyz = obs.geometry
         natom = len(xyz[0])
         nm2bohr = 1.88973
         for snap in xyz:
-            f.write('%d \n\n' % natom)
+            f.write("%d \n\n" % natom)
             for i, pos in enumerate(snap):
                 at = self.wf.atoms[i]
-                f.write('%s % 7.5f % 7.5f %7.5f\n' % (at[0],
-                                                      pos[0] /
-                                                      nm2bohr,
-                                                      pos[1] /
-                                                      nm2bohr,
-                                                      pos[2] / nm2bohr))
-            f.write('\n')
+                f.write(
+                    "%s % 7.5f % 7.5f %7.5f\n"
+                    % (at[0], pos[0] / nm2bohr, pos[1] / nm2bohr, pos[2] / nm2bohr)
+                )
+            f.write("\n")
         f.close()
 
-    def run(self, nepoch, batchsize=None, loss='variance'):
+    def run(self, nepoch: int, batchsize: Optional[int] = None, loss: str = "variance"):
         raise NotImplementedError()
 
-    def log_data(self):
+    def log_data(self) -> None:
         """Log basic information about the sampler."""
 
-        log.info('')
-        log.info(' QMC Solver ')
+        log.info("")
+        log.info(" QMC Solver ")
 
         if self.wf is not None:
-            log.info(
-                '  WaveFunction        : {0}', self.wf.__class__.__name__)
-            for x in self.wf.__repr__().split('\n'):
-                log.debug('   ' + x)
+            log.info("  WaveFunction        : {0}", self.wf.__class__.__name__)
+            for x in self.wf.__repr__().split("\n"):
+                log.debug("   " + x)
 
         if self.sampler is not None:
-            log.info(
-                '  Sampler             : {0}', self.sampler.__class__.__name__)
-            for x in self.sampler.__repr__().split('\n'):
-                log.debug('   ' + x)
+            log.info("  Sampler             : {0}", self.sampler.__class__.__name__)
+            for x in self.sampler.__repr__().split("\n"):
+                log.debug("   " + x)
 
         if self.opt is not None:
-            log.info(
-                '  Optimizer           : {0}', self.opt.__class__.__name__)
-            for x in self.opt.__repr__().split('\n'):
-                log.debug('   ' + x)
+            log.info("  Optimizer           : {0}", self.opt.__class__.__name__)
+            for x in self.opt.__repr__().split("\n"):
+                log.debug("   " + x)
 
         if self.scheduler is not None:
-            log.info(
-                '  Scheduler           : {0}', self.scheduler.__class__.__name__)
-            for x in self.scheduler.__repr__().split('\n'):
-                log.debug('   ' + x)
+            log.info("  Scheduler           : {0}", self.scheduler.__class__.__name__)
+            for x in self.scheduler.__repr__().split("\n"):
+                log.debug("   " + x)
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index d39c26e6..15c3a124 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -1,11 +1,12 @@
 from time import time
 from types import SimpleNamespace
+from typing import Optional, Dict, Union, List, Tuple, Any
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
 
 import torch
-from torch.utils.data import DataLoader
-
-from qmctorch.utils import (DataSet, Loss, OrthoReg, add_group_attr,
-                            dump_to_hdf5)
+from ..utils import DataLoader, add_group_attr, dump_to_hdf5
+from .loss import Loss
 
 from .. import log
 from .solver import Solver
@@ -16,15 +17,21 @@
     pass
 
 
-def logd(rank, *args):
+def logd(rank: int, *args):
     if rank == 0:
         log.info(*args)
 
 
 class SolverMPI(Solver):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(        
+            self,
+            wf: Optional[WaveFunction] = None,
+            sampler: Optional[SamplerBase] = None,
+            optimizer: Optional[torch.optim.Optimizer] = None,
+            scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+            output: Optional[str] = None,
+            rank: int = 0,
+        ) -> None:
         """Distributed QMC solver
 
         Args:
@@ -36,19 +43,26 @@ def __init__(self, wf=None, sampler=None, optimizer=None,
             rank (int, optional): rank of he process. Defaults to 0.
         """
 
-        super().__init__(wf, sampler,
-                         optimizer, scheduler, output, rank)
+        super().__init__(wf, sampler, optimizer, scheduler, output, rank)
 
         hvd.broadcast_optimizer_state(self.opt, root_rank=0)
         self.opt = hvd.DistributedOptimizer(
-            self.opt, named_parameters=self.wf.named_parameters())
+            self.opt, named_parameters=self.wf.named_parameters()
+        )
 
-        self.sampler.nwalkers //= hvd.size()
         self.sampler.walkers.nwalkers //= hvd.size()
 
-    def run(self, nepoch, batchsize=None, loss='energy',
-            clip_loss=False, grad='manual', hdf5_group='wf_opt',
-            num_threads=1, chkpt_every=None):
+    def run(  # pylint: disable=too-many-arguments
+        self,
+        nepoch: int,
+        batchsize: Optional[int] = None,
+        loss: str = "energy",
+        clip_loss: bool = False,
+        grad: str = "manual",
+        hdf5_group: str = "wf_opt",
+        num_threads: int = 1,
+        chkpt_every: Optional[int] = None,
+    ) -> SimpleNamespace:
         """Run the optimization
 
         Args:
@@ -66,21 +80,27 @@ def run(self, nepoch, batchsize=None, loss='energy',
                                     Defaults to 'wf_opt'
         """
 
-        logd(hvd.rank(), '')
-        logd(hvd.rank(),
-             '  Distributed Optimization on {num} process'.format(num=hvd.size()))
-        log.info('   - Process {id} using {nw} walkers'.format(
-                 id=hvd.rank(), nw=self.sampler.nwalkers))
+        logd(hvd.rank(), "")
+        logd(
+            hvd.rank(),
+            "  Distributed Optimization on {num} process".format(num=hvd.size()),
+        )
+        log.info(
+            "   - Process {id} using {nw} walkers".format(
+                id=hvd.rank(), nw=self.sampler.walkers.nwalkers
+            )
+        )
 
         # observable
-        if not hasattr(self, 'observable'):
-            self.track_observable(['local_energy'])
+        if not hasattr(self, "observable"):
+            self.track_observable(["local_energy"])
 
         self.evaluate_gradient = {
-            'auto': self.evaluate_grad_auto,
-            'manual': self.evaluate_grad_manual}[grad]
+            "auto": self.evaluate_grad_auto,
+            "manual": self.evaluate_grad_manual,
+        }[grad]
 
-        if 'lpos_needed' not in self.opt.__dict__.keys():
+        if "lpos_needed" not in self.opt.__dict__.keys():
             self.opt.lpos_needed = False
 
         self.wf.train()
@@ -90,16 +110,12 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
         # get the loss
         self.loss = Loss(self.wf, method=loss, clip=clip_loss)
-        self.loss.use_weight = (
-            self.resampling_options.resample_every > 1)
-
-        # orthogonalization penalty for the MO coeffs
-        self.ortho_loss = OrthoReg()
+        self.loss.use_weight = self.resampling_options.resample_every > 1
 
         self.prepare_optimization(batchsize, chkpt_every)
         # log data
         if hvd.rank() == 0:
-            self.log_data_opt(nepoch, 'wave function optimization')
+            self.log_data_opt(nepoch, "wave function optimization")
 
         # sample the wave function
         if hvd.rank() == 0:
@@ -122,35 +138,24 @@ def run(self, nepoch, batchsize=None, loss='energy',
         _nstep_save = self.sampler.nstep
         _ntherm_save = self.sampler.ntherm
         _nwalker_save = self.sampler.walkers.nwalkers
-        if self.resampling_options.mode == 'update':
+        if self.resampling_options.mode == "update":
             self.sampler.ntherm = -1
             self.sampler.nstep = self.resampling_options.nstep_update
             self.sampler.walkers.nwalkers = pos.shape[0]
-            self.sampler.nwalkers = pos.shape[0]
 
         # create the data loader
-        self.dataset = DataSet(pos)
-
-        if self.cuda:
-            kwargs = {'num_workers': num_threads, 'pin_memory': True}
-        else:
-            kwargs = {'num_workers': num_threads}
-
-        self.dataloader = DataLoader(self.dataset,
-                                     batch_size=batchsize,
-                                     **kwargs)
-        min_loss = 1E3
+        # self.dataset = DataSet(pos)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
+        min_loss = 1e3
 
         for n in range(nepoch):
-
             tstart = time()
-            logd(hvd.rank(), '')
-            logd(hvd.rank(), '  epoch %d' % n)
+            logd(hvd.rank(), "")
+            logd(hvd.rank(), "  epoch %d" % n)
 
-            cumulative_loss = 0.
+            cumulative_loss = 0.0
 
             for ibatch, data in enumerate(self.dataloader):
-
                 # get data
                 lpos = data.to(self.device)
                 lpos.requires_grad = True
@@ -164,16 +169,13 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
                 # observable
                 if hvd.rank() == 0:
-                    self.store_observable(
-                        pos, local_energy=eloc, ibatch=ibatch)
+                    self.store_observable(pos, local_energy=eloc, ibatch=ibatch)
 
-            cumulative_loss = self.metric_average(cumulative_loss,
-                                                  'cum_loss')
+            cumulative_loss = self.metric_average(cumulative_loss, "cum_loss")
 
             if hvd.rank() == 0:
                 if n == 0 or cumulative_loss < min_loss:
-                    self.observable.models.best = dict(
-                        self.wf.state_dict())
+                    self.observable.models.best = dict(self.wf.state_dict())
                 min_loss = cumulative_loss
 
                 if self.chkpt_every is not None:
@@ -190,26 +192,31 @@ def run(self, nepoch, batchsize=None, loss='energy',
             if self.scheduler is not None:
                 self.scheduler.step()
 
-            logd(hvd.rank(), '  epoch done in %1.2f sec.' %
-                 (time()-tstart))
+            logd(hvd.rank(), "  epoch done in %1.2f sec." % (time() - tstart))
 
         # restore the sampler number of step
         self.sampler.nstep = _nstep_save
         self.sampler.ntherm = _ntherm_save
         self.sampler.walkers.nwalkers = _nwalker_save
-        self.sampler.nwalkers = _nwalker_save
 
         if hvd.rank() == 0:
             dump_to_hdf5(self.observable, self.hdf5file, hdf5_group)
-            add_group_attr(self.hdf5file, hdf5_group, {'type': 'opt'})
+            add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
         return self.observable
 
-    def single_point(self, with_tqdm=True, hdf5_group='single_point'):
+    def single_point(
+        self, 
+        with_tqdm: bool = True, 
+        batchsize: Optional[int] = None, 
+        hdf5_group: str = "single_point"
+    ) -> SimpleNamespace:
         """Performs a single point calculation
 
         Args:
             with_tqdm (bool, optional): use tqdm for samplig. Defaults to True.
+            batchsize (int, optional): Number of sample in a mini batch. If None, all samples are used.
+                                      Defaults to Never.
             hdf5_group (str, optional): hdf5 group where to store the data.
                                         Defaults to 'single_point'.
 
@@ -217,13 +224,20 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
             SimpleNamespace: contains the local energy, positions, ...
         """
 
-        logd(hvd.rank(), '')
-        logd(hvd.rank(), '  Single Point Calculation : {nw} walkers | {ns} steps'.format(
-             nw=self.sampler.nwalkers, ns=self.sampler.nstep))
+        logd(hvd.rank(), "")
+        logd(
+            hvd.rank(),
+            "  Single Point Calculation : {nw} walkers | {ns} steps".format(
+                nw=self.sampler.walkers.nwalkers, ns=self.sampler.nstep
+            ),
+        )
+
+        if batchsize is not None:
+            log.info("  Batchsize not supported for MPI solver")
 
         # check if we have to compute and store the grads
         grad_mode = torch.no_grad()
-        if self.wf.kinetic == 'auto':
+        if self.wf.kinetic == "auto":
             grad_mode = torch.enable_grad()
 
         # distribute the calculation
@@ -232,59 +246,52 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
         torch.set_num_threads(num_threads)
 
         with grad_mode:
-
             # sample the wave function
-            pos = self.sampler(self.wf.pdf)
-            if self.wf.cuda and pos.device.type == 'cpu':
+            pos: torch.tensor = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
+            if self.wf.cuda and pos.device.type == "cpu":
                 pos = pos.to(self.device)
 
             # compute energy/variance/error
-            eloc = self.wf.local_energy(pos)
-            e, s, err = torch.mean(eloc), torch.var(
-                eloc), self.wf.sampling_error(eloc)
+            eloc: torch.tensor = self.wf.local_energy(pos)
+            e: torch.tensor = torch.mean(eloc)
+            s: torch.tensor = torch.var(eloc)
+            err: torch.tensor = self.wf.sampling_error(eloc)
 
             # gather all data
-            eloc_all = hvd.allgather(eloc, name='local_energies')
-            e, s, err = torch.mean(eloc_all), torch.var(
-                eloc_all), self.wf.sampling_error(eloc_all)
+            eloc_all: torch.tensor = hvd.allgather(eloc, name="local_energies")
+            e = torch.mean(eloc_all)
+            s = torch.var(eloc_all)
+            err = self.wf.sampling_error(eloc_all)
 
             # print
             if hvd.rank() == 0:
-                log.options(style='percent').info(
-                    '  Energy   : %f +/- %f' % (e.detach().item(), err.detach().item()))
-                log.options(style='percent').info(
-                    '  Variance : %f' % s.detach().item())
+                log.options(style="percent").info(
+                    "  Energy   : %f +/- %f" % (e.detach().item(), err.detach().item())
+                )
+                log.options(style="percent").info("  Variance : %f" % s.detach().item())
 
             # dump data to hdf5
-            obs = SimpleNamespace(
-                pos=pos,
-                local_energy=eloc_all,
-                energy=e,
-                variance=s,
-                error=err
+            obs: SimpleNamespace = SimpleNamespace(
+                pos=pos, local_energy=eloc_all, energy=e, variance=s, error=err
             )
 
             # dump to file
             if hvd.rank() == 0:
-
-                dump_to_hdf5(obs,
-                             self.hdf5file,
-                             root_name=hdf5_group)
-                add_group_attr(self.hdf5file, hdf5_group,
-                               {'type': 'single_point'})
+                dump_to_hdf5(obs, self.hdf5file, root_name=hdf5_group)
+                add_group_attr(self.hdf5file, hdf5_group, {"type": "single_point"})
 
         return obs
 
     @staticmethod
-    def metric_average(val, name):
-        """Average a give quantity over all processes
+    def metric_average(val: torch.Tensor, name: str) -> float:
+        """Average a given quantity over all processes
 
-        Arguments:
-            val {torch.tensor} -- data to average
-            name {str} -- name of the data
+        Args:
+            val (torch.Tensor): data to average
+            name (str): name of the data
 
         Returns:
-            torch.tensor -- Averaged quantity
+            float: Averaged quantity
         """
         tensor = val.clone().detach()
         avg_tensor = hvd.allreduce(tensor, name=name)
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index aa7486ab..0c2e97c2 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -1,34 +1,52 @@
 """Utils module API."""
 
 from .algebra_utils import bdet2, bproj, btrace
-from .hdf5_utils import (add_group_attr, dump_to_hdf5, load_from_hdf5,
-                         register_extra_attributes, bytes2str)
-from .interpolate import (InterpolateAtomicOrbitals,
-                          InterpolateMolecularOrbitals)
-from .plot_data import (plot_block, plot_blocking_energy,
-                        plot_correlation_coefficient, plot_correlation_time,
-                        plot_data, plot_energy,
-                        plot_integrated_autocorrelation_time,
-                        plot_walkers_traj)
-from .stat_utils import (blocking, correlation_coefficient,
-                         integrated_autocorrelation_time)
-from .torch_utils import (DataSet, Loss, OrthoReg, fast_power,
-                          set_torch_double_precision,
-                          set_torch_single_precision,
-                          diagonal_hessian, gradients)
+from .provenance import get_git_tag
+from .hdf5_utils import (
+    add_group_attr,
+    dump_to_hdf5,
+    load_from_hdf5,
+    register_extra_attributes,
+    bytes2str,
+)
+from .interpolate import InterpolateAtomicOrbitals, InterpolateMolecularOrbitals
 
-__all__ = ['plot_energy', 'plot_data', 'plot_block',
-           'plot_walkers_traj',
-           'plot_correlation_time',
-           'plot_autocorrelation',
-           'set_torch_double_precision',
-           'set_torch_single_precision',
-           'DataSet', 'Loss', 'OrthoReg',
-           'dump_to_hdf5', 'load_from_hdf5',
-           'bytes2str',
-           'register_extra_attributes',
-           'fast_power',
-           'InterpolateMolecularOrbitals',
-           'InterpolateAtomicOrbitals',
-           'btrace', 'bdet2', 'bproj',
-           'diagonal_hessian', 'gradients']
+
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    integrated_autocorrelation_time,
+)
+
+from .torch_utils import (
+    DataSet,
+    DataLoader,
+    fast_power,
+    set_torch_double_precision,
+    set_torch_single_precision,
+    diagonal_hessian,
+    gradients,
+)
+
+__all__ = [
+    "set_torch_double_precision",
+    "set_torch_single_precision",
+    "DataSet",
+    "DataLoader",
+    "add_group_attr",
+    "dump_to_hdf5",
+    "load_from_hdf5",
+    "bytes2str",
+    "register_extra_attributes",
+    "fast_power",
+    "InterpolateMolecularOrbitals",
+    "InterpolateAtomicOrbitals",
+    "btrace",
+    "bdet2",
+    "bproj",
+    "diagonal_hessian",
+    "gradients",
+    "blocking",
+    "correlation_coefficient",
+    "integrated_autocorrelation_time",
+]
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index 914d14c4..f8d2a5de 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -1,37 +1,34 @@
 import torch
 import numpy as np
+from typing import List
 from scipy.special import factorial2 as f2
 
-def btrace(M):
+def btrace(M: torch.Tensor) -> torch.Tensor:
     """Computes the trace of batched matrices
 
     Args:
-        M (torch.tensor): matrices of size (Na, Nb, ... Nx, N, N)
+        M: matrices of size (Na, Nb, ... Nx, N, N)
 
     Returns:
-        torch.tensor: trace of matrices (Na, Nb, ... Nx)
-
-    Example:
-        >>> m = torch.rand(100,5,5)
-        >>> tr = btrace(m)
+        trace of matrices (Na, Nb, ... Nx)
     """
     return torch.diagonal(M, dim1=-2, dim2=-1).sum(-1)
 
 
-def bproj(M, P):
-    """Project batched marices using P^T M P
+def bproj(M: torch.Tensor, P: torch.Tensor) -> torch.Tensor:
+    """Project batched matrices using P^T M P
 
     Args:
-        M (torch.tensor): batched matrices size (..., N, M)
-        P (torch.tensor): Porjectors size (..., N, M)
+        M (torch.Tensor): Batched matrices of size (..., N, M)
+        P (torch.Tensor): Projectors of size (..., N, M)
 
     Returns:
-        torch.tensor: Projected matrices
+        torch.Tensor: Projected matrices
     """
-    return P.transpose(1, 2) @ M @ P
+    return P.transpose(-1, -2) @ M @ P
 
 
-def bdet2(M):
+def bdet2(M: torch.Tensor) -> torch.Tensor:
     """Computes the determinant of batched 2x2 matrices
 
     Args:
@@ -44,7 +41,7 @@ def bdet2(M):
     return M[..., 0, 0] * M[..., 1, 1] - M[..., 0, 1] * M[..., 1, 0]
 
 
-def double_factorial(input):
+def double_factorial(input: List) -> np.ndarray:
     """Computes the double factorial of an array of int
 
     Args:
@@ -58,33 +55,34 @@ def double_factorial(input):
 
 
 class BatchDeterminant(torch.autograd.Function):
-
     @staticmethod
     def forward(ctx, input):
-
         # LUP decompose the matrices
         inp_lu, pivots = input.lu()
-        perm, inpl, inpu = torch.lu_unpack(inp_lu, pivots)
+        _, _, inpu = torch.lu_unpack(inp_lu, pivots)
 
         # get the number of permuations
-        s = (pivots != torch.as_tensor(
-            range(1, input.shape[1]+1)).int()).sum(1).type(torch.get_default_dtype())
+        s = (
+            (pivots != torch.as_tensor(range(1, input.shape[1] + 1)).int())
+            .sum(1)
+            .type(torch.get_default_dtype())
+        )
 
         # get the prod of the diag of U
         d = torch.diagonal(inpu, dim1=-2, dim2=-1).prod(1)
 
         # assemble
-        det = ((-1)**s * d)
+        det = (-1) ** s * d
         ctx.save_for_backward(input, det)
 
         return det
 
     @staticmethod
     def backward(ctx, grad_output):
-        '''using jaobi's formula
+        """using jaobi's formula
             d det(A) / d A_{ij} = adj^T(A)_{ij}
         using the adjunct formula
             d det(A) / d A_{ij} = ( (det(A) A^{-1})^T )_{ij}
-        '''
+        """
         input, det = ctx.saved_tensors
         return (grad_output * det).view(-1, 1, 1) * torch.inverse(input).transpose(1, 2)
diff --git a/qmctorch/utils/constants.py b/qmctorch/utils/constants.py
new file mode 100644
index 00000000..ff8745e0
--- /dev/null
+++ b/qmctorch/utils/constants.py
@@ -0,0 +1,2 @@
+ANGS2BOHR = 1.8897259886
+BOHR2ANGS = 0.529177
\ No newline at end of file
diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 87036463..cb7a46a7 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -6,19 +6,21 @@
 
 from .. import log
 
-
 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)))
+    log.critical(
+        "Issue inserting data {0} of type {type}", obj_name, type=str(type(obj))
+    )
 
 
 def print_insert_type_error(obj, obj_name):
-    log.critical('Issue inserting type of data {0}} ({type}})' %
-                 obj_name, type=str(type(obj)))
-    
+    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)
+    log.critical("Issue loading {grp}", grp=grp)
 
 
 def load_from_hdf5(obj, fname, obj_name):
@@ -30,7 +32,7 @@ def load_from_hdf5(obj, fname, obj_name):
         obj_name {str} -- name of the root group in the hdf5
     """
 
-    h5 = h5py.File(fname, 'r')
+    h5 = h5py.File(fname, "r")
     root_grp = h5[obj_name]
 
     load_object(root_grp, obj, obj_name)
@@ -47,7 +49,6 @@ def load_object(grp, parent_obj, grp_name):
     """
 
     for child_grp_name, child_grp in grp.items():
-
         if isgroup(child_grp):
             load_group(child_grp, parent_obj, child_grp_name)
         else:
@@ -64,13 +65,10 @@ def load_group(grp, parent_obj, grp_name):
     """
     try:
         if not hasattr(parent_obj, grp_name):
-            parent_obj.__setattr__(
-                grp_name, SimpleNamespace())
-        load_object(grp,
-                    parent_obj.__getattribute__(
-                        grp_name),
-                    grp_name)
-    except:
+            parent_obj.__setattr__(grp_name, SimpleNamespace())
+        load_object(grp, parent_obj.__getattribute__(grp_name), grp_name)
+    except Exception as expt_message:
+        print(expt_message)
         print_load_error(grp_name)
 
 
@@ -83,8 +81,7 @@ def load_data(grp, parent_obj, grp_name):
         grp_name {str} -- name of the group
     """
     try:
-        parent_obj.__setattr__(grp_name,
-                               cast_loaded_data(grp[()]))
+        parent_obj.__setattr__(grp_name, cast_loaded_data(grp[()]))
     except:
         print_load_error(grp_name)
 
@@ -103,17 +100,17 @@ def cast_loaded_data(data):
 def bytes2str(bstr):
     """Convert a bytes into string."""
     if type(bstr) is bytes:
-        return bstr.decode('utf-8')
+        return bstr.decode("utf-8")
     elif type(bstr) is str:
         return bstr
     else:
         raise TypeError(
-            bstr, ' should be a bytes or str but got ', type(bstr), ' instead')
+            bstr, " should be a bytes or str but got ", type(bstr), " instead"
+        )
 
 
 def lookup_cast(ori_type, current_type):
-    raise NotImplementedError(
-        "cast the data to the type contained in .attrs['type']")
+    raise NotImplementedError("cast the data to the type contained in .attrs['type']")
 
 
 def isgroup(grp):
@@ -140,23 +137,22 @@ def dump_to_hdf5(obj, fname, root_name=None):
         root_name {str} -- root group in the hdf5 file (default: {None})
     """
 
-    h5 = h5py.File(fname, 'a')
+    h5 = h5py.File(fname, "a")
 
     if root_name is None:
         root_name = obj.__class__.__name__
 
     # change root name if that name is already present in the file
     if root_name in h5:
-
-        log.info('')
-        log.info(' Warning : dump to hdf5')
+        log.info("")
+        log.info(" Warning : dump to hdf5")
         log.info(
-            ' Object {obj} already exists in {parent}', obj=root_name, parent=fname)
+            " Object {obj} already exists in {parent}", obj=root_name, parent=fname
+        )
         n = sum(1 for n in h5 if n.startswith(root_name)) + 1
-        root_name = root_name + '_' + str(n)
-        log.info(
-            ' Object name changed to {obj}', obj=root_name)
-        log.info('')
+        root_name = root_name + "_" + str(n)
+        log.info(" Object name changed to {obj}", obj=root_name)
+        log.info("")
 
     insert_object(obj, h5, root_name)
     h5.close()
@@ -189,35 +185,38 @@ def insert_group(obj, parent_grp, obj_name):
 
     # ignore object starting with underscore
     # a lot of pytorch internal are like that
-    if obj_name.startswith('_'):
+    if obj_name.startswith("_"):
         log.debug(
-            ' Warning : Object {obj} not stored in {parent}', obj=obj_name, parent=parent_grp)
-        log.debug(
-            '         : because object name starts with "_"')
+            " Warning : Object {obj} not stored in {parent}",
+            obj=obj_name,
+            parent=parent_grp,
+        )
+        log.debug('         : because object name starts with "_"')
         return
 
     # store if the object name is not in parent
     if obj_name not in parent_grp:
-
         try:
             own_grp = parent_grp.create_group(obj_name)
 
             for child_name in get_children_names(obj):
                 child_obj = get_child_object(obj, child_name)
-                insert_object(child_obj,  own_grp, child_name)
+                insert_object(child_obj, own_grp, child_name)
 
         except Exception as inst:
             print(type(inst))
             print(inst)
-            
+
             print_insert_error(obj, obj_name)
 
     # if something went wrong anyway
     else:
         log.critical(
-            ' Warning : Object {obj} already exists in {parent}', obj=obj_name, parent=parent_grp)
-        log.critical(
-            ' Warning : Keeping original version of the data')
+            " Warning : Object {obj} already exists in {parent}",
+            obj=obj_name,
+            parent=parent_grp,
+        )
+        log.critical(" Warning : Keeping original version of the data")
 
 
 def insert_data(obj, parent_grp, obj_name):
@@ -229,17 +228,19 @@ def insert_data(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
 
-    if obj_name.startswith('_'):
+    if obj_name.startswith("_"):
         return
 
     try:
-        lookup_insert = {list: insert_list,
-                         tuple: insert_tuple,
-                         np.ndarray: insert_numpy,
-                         torch.Tensor: insert_torch_tensor,
-                         torch.nn.parameter.Parameter: insert_torch_parameter,
-                         torch.device: insert_none,
-                         type(None): insert_none}
+        lookup_insert = {
+            list: insert_list,
+            tuple: insert_tuple,
+            np.ndarray: insert_numpy,
+            torch.Tensor: insert_torch_tensor,
+            torch.nn.parameter.Parameter: insert_torch_parameter,
+            torch.device: insert_none,
+            type(None): insert_none,
+        }
 
         insert_fn = lookup_insert[type(obj)]
     except KeyError:
@@ -262,7 +263,7 @@ def insert_type(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
     try:
-        parent_grp[obj_name].attrs['type'] = str(type(obj))
+        parent_grp[obj_name].attrs["type"] = str(type(obj))
     except:
         print_insert_type_error(obj, obj_name)
 
@@ -291,16 +292,15 @@ def insert_list(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
 
-    
     try:
-        if np.all([isinstance(el,torch.Tensor) for el in 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:
-                insert_object(l, parent_grp, obj_name+'_'+str(il))
+                insert_object(l, parent_grp, obj_name + "_" + str(il))
             except:
                 print_insert_error(obj, obj_name)
 
@@ -313,6 +313,8 @@ def insert_tuple(obj, parent_grp, obj_name):
         parent_grp {hdf5 group} -- group where to dump
         obj_name {str} -- name of the object
     """
+    # fix for type torch.Tensor
+    obj = [o.cpu().numpy() if isinstance(o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 
@@ -324,8 +326,8 @@ def insert_numpy(obj, parent_grp, obj_name):
         parent_grp {hdf5 group} -- group where to dump
         obj_name {str} -- name of the object
     """
-    if obj.dtype.str.startswith('<U'):
-        obj = obj.astype('S')
+    if obj.dtype.str.startswith("<U"):
+        obj = obj.astype("S")
     insert_default(obj, parent_grp, obj_name)
 
 
@@ -375,7 +377,7 @@ def haschildren(obj):
     if type(obj) in ommit_type:
         return False
     else:
-        return hasattr(obj, '__dict__') or hasattr(obj, 'keys')
+        return hasattr(obj, "__dict__") or hasattr(obj, "keys")
 
 
 def children(obj):
@@ -388,10 +390,10 @@ def children(obj):
         dict -- items
     """
 
-    if hasattr(obj, '__dict__'):
+    if hasattr(obj, "__dict__"):
         return obj.__dict__.items()
 
-    elif hasattr(obj, 'keys'):
+    elif hasattr(obj, "keys"):
         return obj.items()
 
 
@@ -405,16 +407,16 @@ def get_children_names(obj):
         dict -- items
     """
 
-    if hasattr(obj, '__dict__'):
+    if hasattr(obj, "__dict__"):
         names = list(obj.__dict__.keys())
 
-    elif hasattr(obj, 'keys'):
+    elif hasattr(obj, "keys"):
         names = list(obj.keys())
 
-    if hasattr(obj, '__extra_attr__'):
+    if hasattr(obj, "__extra_attr__"):
         names += obj.__extra_attr__
 
-    if hasattr(obj, 'state_dict'):
+    if hasattr(obj, "state_dict"):
         names += list(obj.state_dict().keys())
 
     return list(set(names))
@@ -431,21 +433,21 @@ def get_child_object(obj, child_name):
         object -- child object
     """
 
-    if hasattr(obj, '__getattr__'):
+    if hasattr(obj, "__getattr__"):
         try:
             return obj.__getattr__(child_name)
 
         except AttributeError:
             pass
 
-    if hasattr(obj, '__getattribute__'):
+    if hasattr(obj, "__getattribute__"):
         try:
             return obj.__getattribute__(child_name)
 
         except AttributeError:
             pass
 
-    if hasattr(obj, '__getitem__'):
+    if hasattr(obj, "__getitem__"):
         try:
             return obj.__getitem__(child_name)
 
@@ -462,7 +464,7 @@ def add_group_attr(filename, grp_name, attr):
         attr {dict} -- attrivutes to add
     """
 
-    h5 = h5py.File(filename, 'a')
+    h5 = h5py.File(filename, "a")
     for k, v in attr.items():
         h5[grp_name].attrs[k] = v
     h5.close()
@@ -475,6 +477,6 @@ def register_extra_attributes(obj, attr_names):
         obj {object} -- the object where we want to add attr
         attr_names {list} -- a list of attr names
     """
-    if not hasattr(obj, '__extra_attr__'):
+    if not hasattr(obj, "__extra_attr__"):
         obj.__extra_attr__ = []
     obj.__extra_attr__ += attr_names
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index 89495ca4..b6fe6702 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -1,5 +1,5 @@
 from time import time
-
+from typing import Union, Tuple, List, Callable
 import numpy as np
 import torch
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
@@ -8,25 +8,39 @@
 # TO DO : Remove this features as they are never used anywhere
 #################################################################################
 
-class InterpolateMolecularOrbitals:
 
+class InterpolateMolecularOrbitals:
     def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
-    def __call__(self, pos, method='irreg', orb='occupied', **kwargs):
+    def __call__(
+        self, pos: torch.Tensor, method: str = "irreg", orb: str = "occupied", **kwargs
+    ) -> torch.Tensor:
+        """
+        Interpolate molecular orbitals on a regular or irregular grid.
 
-        if method == 'irreg':
-            n = kwargs['n'] if 'n' in kwargs else 6
-            return self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
+        Args:
+            pos (torch.Tensor): positions of the walkers
+            method (str): method to use "irreg" or "reg". Defaults to "irreg".
+            orb (str): occupied or all. Defaults to "occupied".
+            **kwargs: keyword arguments to be passed to the interpolation
+                methods.
 
-        elif method == 'reg':
-            rstr, bstr = 'resolution', 'border_length'
+        Returns:
+            torch.Tensor: interpolated mo values
+        """
+        if method == "irreg":
+            n = kwargs["n"] if "n" in kwargs else 6
+            out = self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
+        elif method == "reg":
+            rstr, bstr = "resolution", "border_length"
             res = kwargs[rstr] if rstr in kwargs else 0.1
-            blength = kwargs[bstr] if bstr in kwargs else 2.
-            return self.interpolate_mo_reg_grid(pos, res, blength, orb)
+            blength = kwargs[bstr] if bstr in kwargs else 2.0
+            out = self.interpolate_mo_reg_grid(pos, res, blength, orb)
+        return out
 
-    def get_mo_max_index(self, orb):
+    def get_mo_max_index(self, orb: str) -> int:
         """Get the index of the highest MO to inlcude in the interpoaltion
 
         Args:
@@ -34,53 +48,57 @@ def get_mo_max_index(self, orb):
 
         Raises:
             ValueError: if orb not valid
+
+        Returns:
+            int: index of the highest MO to inlcude in the interpoaltion
         """
 
-        if orb == 'occupied':
-            self.mo_max_index = torch.stack(
-                self.wf.configs).max().item()+1
-        elif orb == 'all':
-            self.mo_max_index = self.wf.mol.basis.nmo+1
+        if orb == "occupied":
+            self.mo_max_index = torch.stack(self.wf.configs).max().item() + 1
+        elif orb == "all":
+            self.mo_max_index = self.wf.mol.basis.nmo + 1
         else:
-            raise ValueError(
-                'orb must occupied or all')
+            raise ValueError("orb must occupied or all")
 
-    def interpolate_mo_irreg_grid(self, pos, n, orb):
-        """Interpolate the mo occupied in the configs.
+    def interpolate_mo_irreg_grid(self, pos: torch.Tensor, n: int, orb: str) -> torch.Tensor:
+        """Interpolate the molecular orbitals occupied in the configs.
 
         Args:
-            pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
-            n (int, optional): Interpolation order. Defaults to 6.
+            pos (torch.Tensor): Sampling points with shape (Nbatch, 3*Nelec).
+            n (int): Interpolation order.
+            orb (str): Type of orbitals to interpolate, either 'occupied' or 'all'.
 
         Returns:
-            torch.tensor: mo values Nbatch, Nelec, Nmo
+            torch.Tensor: Interpolated molecular orbital values with shape (Nbatch, Nelec, Nmo).
         """
         self.get_mo_max_index(orb)
 
-        if not hasattr(self, 'interp_mo_func'):
+        if not hasattr(self, "interp_mo_func"):
             grid_pts = get_log_grid(self.wf.mol.atom_coords, n=n)
 
-            def func(x):
+            def func(x: torch.Tensor) -> torch.Tensor:
                 x = torch.as_tensor(x).type(torch.get_default_dtype())
                 ao = self.wf.ao(x, one_elec=True)
-                mo = self.wf.mo(self.wf.mo_scf(ao)).squeeze(1)
-                return mo[:, :self.mo_max_index].detach()
+                mo = self.wf.mo(ao).squeeze(1)
+                return mo[:, : self.mo_max_index].detach()
 
-            self.interp_mo_func = interpolator_irreg_grid(
-                func, grid_pts)
+            self.interp_mo_func = interpolator_irreg_grid(func, grid_pts)
 
         nbatch = pos.shape[0]
-        mos = torch.zeros(nbatch, self.wf.mol.nelec,
-                          self.wf.mol.basis.nmo)
-        mos[:, :, :self.mo_max_index] = interpolate_irreg_grid(
-            self.interp_mo_func, pos)
+        mos = torch.zeros(nbatch, self.wf.mol.nelec, self.wf.mol.basis.nmo)
+        mos[:, :, :self.mo_max_index] = interpolate_irreg_grid(self.interp_mo_func, pos)
         return mos
 
-    def interpolate_mo_reg_grid(self, pos,  res, blength, orb):
+    def interpolate_mo_reg_grid(
+        self, pos: torch.Tensor, res: int, blength: float, orb: str
+    ) -> torch.Tensor:
         """Interpolate the mo occupied in the configs.
 
         Args:
             pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
+            res (int): resolution of the regular grid
+            blength (float): border length of the regular grid
+            orb (str): Type of orbitals to interpolate, either 'occupied' or 'all'
 
         Returns:
             torch.tensor: mo values Nbatch, Nelec, Nmo
@@ -88,117 +106,134 @@ def interpolate_mo_reg_grid(self, pos,  res, blength, orb):
 
         self.get_mo_max_index(orb)
 
-        if not hasattr(self, 'interp_mo_func'):
+        if not hasattr(self, "interp_mo_func"):
             x, y, z = get_reg_grid(
-                self.wf.mol.atom_coords, resolution=res, border_length=blength)
+                self.wf.mol.atom_coords, resolution=res, border_length=blength
+            )
 
             def func(x):
                 x = torch.as_tensor(x).type(torch.get_default_dtype())
                 ao = self.wf.ao(x, one_elec=True)
-                mo = self.wf.mo(self.wf.mo_scf(ao)).squeeze(1)
-                return mo[:, :self.mo_max_index]
+                mo = self.wf.mo(ao).squeeze(1)
+                return mo[:, : self.mo_max_index]
 
-            self.interp_mo_func = interpolator_reg_grid(
-                func, x, y, z)
+            self.interp_mo_func = interpolator_reg_grid(func, x, y, z)
 
         nbatch = pos.shape[0]
-        mos = torch.zeros(nbatch, self.wf.mol.nelec,
-                          self.wf.mol.basis.nmo)
-        mos[:, :, :self.mo_max_index] = interpolate_reg_grid(
-            self.interp_mo_func, pos)
+        mos = torch.zeros(nbatch, self.wf.mol.nelec, self.wf.mol.basis.nmo)
+        mos[:, :, : self.mo_max_index] = interpolate_reg_grid(self.interp_mo_func, pos)
         return mos
 
 
 class InterpolateAtomicOrbitals:
-
     def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
-    def __call__(self, pos, n=6, length=2):
+    def __call__(self, pos: torch.Tensor, n: int = 6, length: float = 2) -> torch.Tensor:
         """Interpolate the AO.
 
         Args:
-            pos (torch.tensor): positions of the walkers
+            pos (torch.tensor): positions of the walkers (Nbatch, Nelec*Ndim)
             n (int, optional): number of points on each log axis. Defaults to 6.
-            length (int, optional): half length of the grid. Defaults to 2.
+            length (float, optional): half length of the grid. Defaults to 2.
 
         Returns:
-            torch.tensor: Interpolated values
+            torch.tensor: Interpolated values (Nbatch, Nelec, Nao)
         """
 
-        if not hasattr(self, 'interp_func'):
+        if not hasattr(self, "interp_func"):
             t0 = time()
-            self.get_interpolator()
-            print('___', time()-t0)
+            self.get_interpolator(n=n, length=length)
+            print("___", time() - t0)
 
         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
+            self.wf.ao.nao_per_atom, dim=0
+        )  # <- we need the number of AO per atom not the number of BAS per atom
 
         t0 = time()
-        xyz = (pos.view(-1, self.wf.ao.nelec, 1, self.wf.ao.ndim) -
-               bas_coords[None, ...]).detach().numpy()
+        xyz = (
+            (pos.view(-1, self.wf.ao.nelec, 1, self.wf.ao.ndim) - bas_coords[None, ...])
+            .detach()
+            .numpy()
+        )
 
         t0 = time()
-        data = np.array([self.interp_func[iorb](xyz[:, :, iorb, :])
-                         for iorb in range(self.wf.ao.norb)])
+        data = np.array(
+            [
+                self.interp_func[iorb](xyz[:, :, iorb, :])
+                for iorb in range(self.wf.ao.norb)
+            ]
+        )
 
         return torch.as_tensor(data.transpose(1, 2, 0))
 
-    def get_interpolator(self, n=6, length=2):
+    def get_interpolator(
+        self, n: int = 6, length: float = 2
+    ) -> None:
         """evaluate the interpolation function.
 
         Args:
             n (int, optional): number of points on each log axis. Defaults to 6.
-            length (int, optional): half length of the grid. Defaults to 2.
-        """
+            length (float, optional): half length of the grid. Defaults to 2.
 
+        Returns:
+            None
+        """
         xpts = logspace(n, length)
         nxpts = len(xpts)
 
-        grid = np.stack(np.meshgrid(
-            xpts, xpts, xpts, indexing='ij')).T.reshape(-1, 3)[:, [2, 1, 0]]
+        grid = np.stack(np.meshgrid(xpts, xpts, xpts, indexing="ij")).T.reshape(-1, 3)[
+            :, [2, 1, 0]
+        ]
 
-        def func(x):
+        def func(x: np.ndarray) -> torch.Tensor:
             x = torch.as_tensor(x).type(torch.get_default_dtype())
             nbatch = x.shape[0]
-            xyz = x.view(-1, 1, 1, 3).expand(-1,
-                                             1, self.wf.ao.nbas, 3)
+            xyz = x.view(-1, 1, 1, 3).expand(-1, 1, self.wf.ao.nbas, 3)
             r = torch.sqrt((xyz**2).sum(3))
-            R = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp)
+            R = self.wf.ao.radial(r, self.wf.ao.bas_n, self.wf.ao.bas_exp)
             Y = self.wf.ao.harmonics(xyz)
             bas = R * Y
             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 = 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
 
         data = func(grid).detach().numpy()
         data = data.reshape(nxpts, nxpts, nxpts, -1)
 
-        self.interp_func = [RegularGridInterpolator((xpts, xpts, xpts),
-                                                    data[..., i],
-                                                    method='linear',
-                                                    bounds_error=False,
-                                                    fill_value=0.) for i in range(self.wf.ao.norb)]
-
-
-def get_boundaries(atomic_positions, border_length=2.):
+        self.interp_func = [
+            RegularGridInterpolator(
+                (xpts, xpts, xpts),
+                data[..., i],
+                method="linear",
+                bounds_error=False,
+                fill_value=0.0,
+            )
+            for i in range(self.wf.ao.norb)
+        ]
+
+
+def get_boundaries(
+    atomic_positions: Union[torch.Tensor, np.ndarray, List[np.ndarray]],
+    border_length: float = 2.0,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Computes the boundaries of the structure
 
     Args:
-        atomic_positions (torch.Tensor, np.ndarray, list): atomic positions
+        atomic_positions (Union[torch.Tensor, np.ndarray, List[np.ndarray]]): atomic positions
         border_length (float, optional): length of the border. Defaults to 2.
 
     Raises:
         ValueError: if type of positions not recognized
 
     Returns:
-        (np.ndarray, np.ndarray, mp.ndarray): min, max values in the 3 cartesian directions
+        Tuple[np.ndarray, np.ndarray, np.ndarray]: min, max values in the 3 cartesian directions
     """
     if isinstance(atomic_positions, torch.Tensor):
         pmin = atomic_positions.min(0)[0].detach().cpu().numpy()
@@ -213,7 +248,8 @@ def get_boundaries(atomic_positions, border_length=2.):
 
     else:
         raise ValueError(
-            'atomic_positions must be either a torch.tensor, np.ndarray, or list')
+            "atomic_positions must be either a torch.tensor, np.ndarray, or list"
+        )
 
     pmin -= border_length
     pmax += border_length
@@ -221,21 +257,24 @@ def get_boundaries(atomic_positions, border_length=2.):
     return pmin, pmax
 
 
-def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.):
+def get_reg_grid(
+    atomic_positions: Union[torch.Tensor, np.ndarray, list], 
+    resolution: float = 0.1, 
+    border_length: float = 2.0
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Computes a regular grid points from the atomic positions
 
     Args:
-        atomic_positions (torch.Tensor, np.ndarray, list): atomic positions
-        resolution (float, optional): ditance between two points. Defaults to 0.5.
-        border_length (float, optional): length of the border. Defaults to 2.
+        atomic_positions (Union[torch.Tensor, np.ndarray, list]): atomic positions
+        resolution (float, optional): distance between two points. Defaults to 0.1.
+        border_length (float, optional): length of the border. Defaults to 2.0.
 
     Returns:
-        (np.ndarray, np.ndarray, mp.ndarray): grid points in the x, y and z axis
+        Tuple[np.ndarray, np.ndarray, np.ndarray]: grid points in the x, y, and z axis
     """
 
-    pmin, pmax = get_boundaries(
-        atomic_positions, border_length=border_length)
-    npts = np.ceil((pmax-pmin) / resolution).astype('int')
+    pmin, pmax = get_boundaries(atomic_positions, border_length=border_length)
+    npts = np.ceil((pmax - pmin) / resolution).astype("int")
 
     x = np.linspace(pmin[0], pmax[0], npts[0])
     y = np.linspace(pmin[1], pmax[1], npts[1])
@@ -244,33 +283,38 @@ def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.):
     return (x, y, z)
 
 
-def interpolator_reg_grid(func, x, y, z):
+def interpolator_reg_grid(
+    func: Callable[[np.ndarray], torch.Tensor],
+    x: np.ndarray,
+    y: np.ndarray,
+    z: np.ndarray,
+) -> Callable[[np.ndarray], np.ndarray]:
     """Computes the interpolation function
 
     Args:
-        func (callable):  compute the value of the funtion to interpolate
+        func (Callable[[np.ndarray], torch.Tensor]): compute the value of the function to interpolate
         x (np.ndarray): grid points in the x direction
         y (np.ndarray): grid points in the y direction
         z (np.ndarray): grid points in the z direction
 
     Returns:
-        callable: interpolation function
+        Callable[[np.ndarray], np.ndarray]: interpolation function
     """
     nx, ny, nz = len(x), len(y), len(z)
-    grid = np.stack(np.meshgrid(
-        z, y, x, indexing='ij')).T.reshape(-1, 3)[:, [2, 1, 0]]
+    grid = np.stack(np.meshgrid(z, y, x, indexing="ij")).T.reshape(-1, 3)[:, [2, 1, 0]]
 
     data = func(grid).detach().numpy()
     data = data.reshape(nx, ny, nz, -1)
-    return RegularGridInterpolator((x, y, z),
-                                   data,
-                                   method='linear',
-                                   bounds_error=False,
-                                   fill_value=0.)
+    return RegularGridInterpolator(
+        (x, y, z), data, method="linear", bounds_error=False, fill_value=0.0
+    )
 
 
-def interpolate_reg_grid(interpfunc, pos):
-    """Interpolate the  funtion
+def interpolate_reg_grid(
+    interpfunc: Callable[[np.ndarray], np.ndarray],
+    pos: torch.Tensor
+) -> torch.Tensor:
+    """Interpolate the function
 
     Args:
         interpfunc (callable): function to interpolate the data points
@@ -280,32 +324,50 @@ def interpolate_reg_grid(interpfunc, pos):
         torch.tensor: interpolated values of the function evaluated at pos
     """
     nbatch = pos.shape[0]
-    nelec = pos.shape[1]//3
+    nelec = pos.shape[1] // 3
     ndim = 3
 
-    data = interpfunc(pos.reshape(
-        nbatch, nelec, ndim).detach().numpy())
+    data = interpfunc(pos.reshape(nbatch, nelec, ndim).detach().numpy())
 
     return torch.as_tensor(data)
 
 
-def is_even(x):
-    """return true if x is even."""
-    return x//2*2 == x
+def is_even(x: int) -> bool:
+    """Return True if x is even.
+
+    Args:
+        x (int): number to test
+
+    Returns:
+        bool: True if x is even
+    """
+    return x // 2 * 2 == x
+
+
+def logspace(n: int, length: float) -> np.ndarray:
+    """Returns a 1d array of logspace between -length and +length.
 
+    Args:
+        n (int): number of points in the array
+        length (float): absolute value of the max distance
 
-def logspace(n, length):
-    """returns a 1d array of logspace between -length and +length."""
-    k = np.log(length+1)/np.log(10)
+    Returns:
+        np.ndarray: 1d array of length n
+    """
+    k = np.log(length + 1) / np.log(10)
     if is_even(n):
-        x = np.logspace(0.01, k, n//2)-1
-        return np.concatenate((-x[::-1], x[1:]))
-    else:
-        x = np.logspace(0.0, k, n//2+1)-1
+        x = np.logspace(0.01, k, n // 2) - 1
         return np.concatenate((-x[::-1], x[1:]))
+    x = np.logspace(0.0, k, n // 2 + 1) - 1
+    return np.concatenate((-x[::-1], x[1:]))
 
 
-def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
+def get_log_grid(
+    atomic_positions: Union[List, np.ndarray, torch.Tensor],
+    n: int = 6,
+    length: float = 2.0,
+    border_length: float = 2.0,
+) -> np.ndarray:
     """Computes a logarithmic grid
 
     Args:
@@ -315,17 +377,14 @@ def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
         border_length (float, optional): length of the border. Defaults to 2.
 
     Returns:
-        np.ndanrray: grid points (Npts,3)
+        np.ndarray: grid points (Npts,3)
     """
 
-    x, y, z = np.stack(get_boundaries(
-        atomic_positions, border_length=border_length)).T
-    grid_pts = np.stack(np.meshgrid(
-        x, y, z, indexing='ij')).T.reshape(-1, 3)
+    x, y, z = np.stack(get_boundaries(atomic_positions, border_length=border_length)).T
+    grid_pts = np.stack(np.meshgrid(x, y, z, indexing="ij")).T.reshape(-1, 3)
 
     x = logspace(n, length)
-    pts = np.stack(np.meshgrid(x, x, x, indexing='ij')
-                   ).T.reshape(-1, 3)
+    pts = np.stack(np.meshgrid(x, x, x, indexing="ij")).T.reshape(-1, 3)
 
     for pos in atomic_positions:
         _tmp = pts + pos
@@ -336,24 +395,24 @@ def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
     return grid_pts
 
 
-def interpolator_irreg_grid(func, grid_pts):
-    """compute a linear ND interpolator
+def interpolator_irreg_grid(func: Callable[[np.ndarray], torch.Tensor], grid_pts: np.ndarray) -> Callable:
+    """Compute a linear ND interpolator
 
     Args:
-        func (callable):  compute the value of the funtion to interpolate
-        grid_pts (np.ndarray): grid points in the x direction
+        func (Callable[[np.ndarray], torch.Tensor]): Function to compute the values to interpolate.
+        grid_pts (np.ndarray): Grid points used for interpolation.
 
     Returns:
-        callable: interpolation function
+        Callable: Interpolation function.
     """
-
-    return LinearNDInterpolator(grid_pts,
-                                func(grid_pts),
-                                fill_value=0.)
+    return LinearNDInterpolator(grid_pts, func(grid_pts), fill_value=0.0)
 
 
-def interpolate_irreg_grid(interpfunc, pos):
-    """Interpolate the  funtion
+def interpolate_irreg_grid(
+    interpfunc: Callable[[np.ndarray], np.ndarray],
+    pos: torch.Tensor
+) -> torch.Tensor:
+    """Interpolate the function
 
     Args:
         interpfunc (callable): function to interpolate the data points
@@ -363,5 +422,5 @@ def interpolate_irreg_grid(interpfunc, pos):
         torch.tensor: interpolated values of the function evaluated at pos
     """
 
-    nbatch, nelec, ndim = pos.shape[0], pos.shape[1]//3, 3
-    return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim)))
+    nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
+    return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim).detach().numpy()))
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 7a5a4ce0..15222765 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -1,20 +1,41 @@
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
-
-from .stat_utils import (blocking, correlation_coefficient,
-                         fit_correlation_coefficient,
-                         integrated_autocorrelation_time)
-
-
-def plot_energy(local_energy, e0=None, show_variance=False):
-    """Plot the evolution of the energy
+from types import SimpleNamespace
+from typing import Optional, Union, Tuple
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    fit_correlation_coefficient,
+    integrated_autocorrelation_time,
+)
+
+
+def plot_energy(
+    local_energy: np.ndarray, 
+    e0: Optional[float] = None, 
+    show_variance: bool = False, 
+    clip: bool = False, 
+    q: float = 0.15,
+) -> None:
+    """Plot the evolution of the energy.
 
     Args:
-        local_energy (np.ndarray): local energies along the trajectory
+        local_energy (np.ndarray): Local energies along the trajectory.
         e0 (float, optional): Target value for the energy. Defaults to None.
-        show_variance (bool, optional): show the variance if True. Defaults to False.
+        show_variance (bool, optional): Show the variance if True. Defaults to False.
+        clip (bool, optional): Clip the values to remove outliers. Defaults to False.
+        q (float, optional): Quantile used for the interquartile range. Defaults to 0.15.
     """
+    def clip_values(values: np.ndarray, std_factor: int = 5) -> np.ndarray:
+        if clip:
+            values = values.flatten()
+            mean = np.median(values)
+            std = values.std()
+            up = values < mean + std_factor * std
+            down = values > mean - std_factor * std
+            return values[up * down]
+        return values
 
     fig = plt.figure()
     ax = fig.add_subplot(111)
@@ -23,35 +44,42 @@ def plot_energy(local_energy, e0=None, show_variance=False):
     epoch = np.arange(n)
 
     # get the variance
-    energy = np.array([np.mean(e) for e in local_energy])
-    variance = np.array([np.var(e) for e in local_energy])
+
+    energy = np.array([np.mean(clip_values(e)) for e in local_energy])
+    variance = np.array([np.var(clip_values(e)) for e in local_energy])
+    q75 = np.array([np.quantile(clip_values(e), 0.5 + q) for e in local_energy])
+    q25 = np.array([np.quantile(clip_values(e), 0.5 - q) for e in local_energy])
 
     # plot
-    ax.fill_between(epoch, energy - variance, energy +
-                    variance, alpha=0.5, color='#4298f4')
-    ax.plot(epoch, energy, color='#144477')
+    ax.fill_between(
+        epoch, q25, q75, alpha=0.5, color="#4298f4"
+    )
+    ax.plot(epoch, energy, color="#144477")
     if e0 is not None:
-        ax.axhline(e0, color='black', linestyle='--')
+        ax.axhline(e0, color="black", linestyle="--")
 
     ax.grid()
-    ax.set_xlabel('Number of epoch')
-    ax.set_ylabel('Energy', color='black')
+    ax.set_xlabel("Number of epoch")
+    ax.set_ylabel("Energy", color="black")
 
     if show_variance:
         ax2 = ax.twinx()
-        ax2.plot(epoch, variance, color='blue')
-        ax2.set_ylabel('variance', color='blue')
-        ax2.tick_params(axis='y', labelcolor='blue')
+        ax2.plot(epoch, variance, color="blue")
+        ax2.set_ylabel("variance", color="blue")
+        ax2.tick_params(axis="y", labelcolor="blue")
         fig.tight_layout()
 
     plt.show()
 
 
-def plot_data(observable, obsname):
-    """Plot the evolution a given data
+def plot_data(
+    observable: SimpleNamespace, 
+    obsname: str
+) -> None:
+    """Plot the evolution of a given data
 
     Args:
-        obs_dict (SimpleNamespace): namespace of observable
+        observable (SimpleNamespace): namespace of observable
         obsname (str): name (key) of the desired observable
     """
 
@@ -60,90 +88,107 @@ def plot_data(observable, obsname):
 
     data = np.array(observable.__dict__[obsname]).squeeze()
     epoch = np.arange(len(data))
-    ax.plot(epoch, data, color='#144477')
+    ax.plot(epoch, data, color="#144477")
 
     plt.show()
 
 
-def plot_walkers_traj(eloc, walkers='mean'):
+def plot_walkers_traj(eloc: np.ndarray, walkers: Union[int, str, None] = "mean") -> None:
     """Plot the trajectory of all the individual walkers
 
     Args:
-        obs (SimpleNamespace): Namespace of the observables
-        walkers (int, str, optional): all, mean or index of a given walker Defaults to 'all'
+        eloc (np.ndarray): Local energy array (Nstep, Nwalkers)
+        walkers (int, str, optional): all, mean or index of a given walker Defaults to 'mean'
+
+    Returns:
+        None
     """
     nstep, nwalkers = eloc.shape
     celoc = np.cumsum(eloc, axis=0).T
     celoc /= np.arange(1, nstep + 1)
 
     if walkers is not None:
-
-        if walkers == 'all':
-            plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
+        if walkers == "all":
+            plt.plot(eloc, "o", alpha=max(1 / nwalkers, 1e-2), c="grey")
             cmap = cm.hot(np.linspace(0, 1, nwalkers))
             for i in range(nwalkers):
                 plt.plot(celoc.T[:, i], color=cmap[i])
 
-        elif walkers == 'mean':
-            plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
+        elif walkers == "mean":
+            plt.plot(eloc, "o", alpha=1 / nwalkers, c="grey")
             emean = np.mean(celoc.T, axis=1)
             emin = emean.min()
             emax = emean.max()
-            delta = emax-emin
+            delta = emax - emin
             plt.plot(emean, linewidth=5)
-            plt.ylim(emin-0.25*delta,emax+0.25*delta)
+            plt.ylim(emin - 0.25 * delta, emax + 0.25 * delta)
         else:
-            raise ValueError('walkers argument must be all or mean')
-        
+            raise ValueError("walkers argument must be all or mean")
+
         plt.grid()
-        plt.xlabel('Monte Carlo Steps')
-        plt.ylabel('Energy (Hartree)')
+        plt.xlabel("Monte Carlo Steps")
+        plt.ylabel("Energy (Hartree)")
 
     plt.show()
 
 
-def plot_correlation_coefficient(eloc, size_max=100):
-    """Plot the correlation coefficient of the local energy
-       and fit the curve to an exp to extract the correlation time.
-
-    Args:
-        eloc (np.ndarray): values of the local energy (Nstep, Nwalk)
-        size_max (int, optional): maximu number of MC step to consider.Defaults to 100.
-
-    Returns:
-        np.ndarray, float: correlation coefficients (size_max, Nwalkers), correlation time
+def plot_correlation_coefficient(
+    eloc: np.ndarray, size_max: int = 100
+) -> Tuple[np.ndarray, float]:
+    """
+    Plot the correlation coefficient of the local energy
+    and fit the curve to an exp to extract the correlation time.
+
+    Parameters
+    ----------
+    eloc : np.ndarray
+        values of the local energy (Nstep, Nwalk)
+    size_max : int, optional
+        maximu number of MC step to consider. Defaults to 100.
+
+    Returns
+    -------
+    rho : np.ndarray
+        correlation coefficients (size_max, Nwalkers)
+    tau_fit : float
+        correlation time
     """
-
     rho = correlation_coefficient(eloc)
-
-    tau_fit, fitted = fit_correlation_coefficient(
-        rho.mean(1)[:size_max])
+    tau_fit, fitted = fit_correlation_coefficient(rho.mean(1)[:size_max])
 
     plt.plot(rho, alpha=0.25)
-    plt.plot(rho.mean(1), linewidth=3, c='black')
-    plt.plot(fitted, '--', c='grey')
+    plt.plot(rho.mean(1), linewidth=3, c="black")
+    plt.plot(fitted, "--", c="grey")
     plt.xlim([0, size_max])
     plt.ylim([-0.25, 1.5])
-    plt.xlabel('MC steps')
-    plt.ylabel('Correlation coefficient')
-    plt.text(0.5*size_max, 1.05, 'tau=%1.3f' %
-             tau_fit, {'color': 'black',  'fontsize': 15})
+    plt.xlabel("MC steps")
+    plt.ylabel("Correlation coefficient")
+    plt.text(
+        0.5 * size_max, 1.05, "tau=%1.3f" % tau_fit, {"color": "black", "fontsize": 15}
+    )
     plt.grid()
     plt.show()
 
     return rho, tau_fit
 
 
-def plot_integrated_autocorrelation_time(eloc, rho=None, size_max=100, C=5):
-    """compute/plot the integrated autocorrelation time
+def plot_integrated_autocorrelation_time(
+    eloc: np.ndarray,
+    rho: np.ndarray = None,
+    size_max: int = 100,
+    C: int = 5
+) -> int:
+    """Compute and plot the integrated autocorrelation time.
 
     Args:
-        eloc (np.ndarray, optional): local energy values (Nstep, Nwalkers)
+        eloc (np.ndarray): Local energy values (Nstep, Nwalkers).
         rho (np.ndarray, optional): Correlation coefficient. Defaults to None.
-        size_max (int, optional): maximu number of MC step to consider.Defaults to 100.
-        C (int, optional): [description]. Defaults to 5.
-    """
+        size_max (int, optional): Maximum number of MC steps to consider. Defaults to 100.
+        C (int, optional): A constant used for thresholding. Defaults to 5.
 
+    Returns:
+        int: Index where the mean integrated autocorrelation time meets the condition.
+    """
     if rho is None:
         rho = correlation_coefficient(eloc)
 
@@ -152,11 +197,9 @@ def plot_integrated_autocorrelation_time(eloc, rho=None, size_max=100, C=5):
     tc, idx_tc = [], []
     idx = np.arange(1, size_max)
     for iw in range(eloc.shape[1]):
-
         t = tau[:, iw]
-        if len(t[C*t <= idx]) > 0:
-
-            tval = t[C*t <= idx][0]
+        if len(t[C * t <= idx]) > 0:
+            tval = t[C * t <= idx][0]
             ii = np.where(t == tval)[0][0]
 
             tc.append(tval)
@@ -164,21 +207,23 @@ def plot_integrated_autocorrelation_time(eloc, rho=None, size_max=100, C=5):
 
     plt.plot(tau, alpha=0.25)
     tm = tau.mean(1)
-    plt.plot(tm, c='black')
-    plt.plot(idx/C, '--', c='grey')
+    plt.plot(tm, c="black")
+    plt.plot(idx / C, "--", c="grey")
 
-    plt.plot(idx_tc, tc, 'o', alpha=0.25)
-    tt = tm[tm*C <= idx][0]
+    plt.plot(idx_tc, tc, "o", alpha=0.25)
+    tt = tm[tm * C <= idx][0]
     ii = np.where(tm == tt)[0][0]
-    plt.plot(ii, tt, 'o')
+    plt.plot(ii, tt, "o")
 
     plt.grid()
-    plt.xlabel('MC step')
-    plt.ylabel('IAC')
+    plt.xlabel("MC step")
+    plt.ylabel("IAC")
     plt.show()
 
+    return ii
+
 
-def plot_blocking_energy(eloc, block_size, walkers='mean'):
+def plot_blocking_energy(eloc: np.ndarray, block_size: int, walkers: str = "mean") -> np.ndarray:
     """Plot the blocked energy values
 
     Args:
@@ -186,41 +231,44 @@ def plot_blocking_energy(eloc, block_size, walkers='mean'):
         block_size (int): size of the block
         walkers (str, optional): which walkers to plot (mean, all, index or list). Defaults to 'mean'.
 
+    Returns:
+        np.ndarray: blocked energy values
+
     Raises:
         ValueError: [description]
     """
     eb = blocking(eloc, block_size, expand=True)
-    if walkers == 'all':
+    if walkers == "all":
         plt.plot(eloc)
         plt.plot(eb)
 
-    elif walkers == 'mean':
+    elif walkers == "mean":
         plt.plot(eloc.mean(1))
         plt.plot(eb.mean(1))
 
-    elif walkers.__class__.__name__ in ['int', 'list']:
+    elif walkers.__class__.__name__ in ["int", "list"]:
         plt.plot(eloc[:, walkers])
         plt.plot(eb[:, walkers])
 
     else:
-        raise ValueError('walkers ', walkers, ' not recognized')
+        raise ValueError("walkers ", walkers, " not recognized")
 
     plt.grid()
-    plt.xlabel('MC steps')
-    plt.ylabel('Energy')
+    plt.xlabel("MC steps")
+    plt.ylabel("Energy")
     plt.show()
 
     return blocking(eloc, block_size, expand=False)
 
 
-def plot_correlation_time(eloc):
+def plot_correlation_time(eloc: np.ndarray) -> None:
     """Plot the blocking thingy
 
     Args:
-        eloc (np.array): values of the local energy
+        eloc (np.ndarray): values of the local energy
     """
 
-    nstep, nwalkers = eloc.shape
+    nstep, _ = eloc.shape
     max_block_size = nstep // 2
 
     var = np.std(eloc, axis=0)
@@ -231,19 +279,22 @@ def plot_correlation_time(eloc):
         evar.append(np.std(eb, axis=0) * size / var)
 
     plt.plot(np.array(evar))
-    plt.xlabel('Blocking size')
-    plt.ylabel('Correlation steps')
+    plt.xlabel("Blocking size")
+    plt.ylabel("Correlation steps")
     plt.show()
 
 
-def plot_block(eloc):
-    """Plot the blocking thingy
+def plot_block(eloc: np.ndarray) -> None:
+    """Plot the standard error of the blocked energies.
 
     Args:
-        eloc (np.array): values of the local energy
+        eloc (np.ndarray): Values of the local energy.
+
+    Returns:
+        None
     """
 
-    nstep, nwalkers = eloc.shape
+    nstep, _ = eloc.shape
     max_block_size = nstep // 2
 
     evar = []
diff --git a/qmctorch/utils/provenance.py b/qmctorch/utils/provenance.py
new file mode 100644
index 00000000..9bc8d7ac
--- /dev/null
+++ b/qmctorch/utils/provenance.py
@@ -0,0 +1,21 @@
+import subprocess
+import os
+from ..__version__ import __version__
+
+
+def get_git_tag() -> str:
+    """
+    Retrieves the current Git tag for the repository.
+
+    This function determines the directory of the current file, then executes
+    a Git command to describe the current commit with the most recent tag.
+    
+    Returns:
+        str: The Git tag string representing the current state of the repository.
+    """
+    try:
+        cwd = os.path.dirname(os.path.abspath(__file__))
+        gittag = subprocess.check_output(["git", "describe", "--always"], cwd=cwd).decode("utf-8").strip("\n")
+        return __version__ + " - " + gittag
+    except:
+        return __version__ + " - hash commit not found"
\ No newline at end of file
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 6daddd8d..e734159d 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,18 +1,27 @@
 import numpy as np
 from scipy.optimize import curve_fit
-
-
-def blocking(x, block_size, expand=False):
+from scipy.signal import fftconvolve
+from typing import Tuple
+
+def blocking(
+    x: np.ndarray,
+    block_size: int,
+    expand: bool = False
+) -> np.ndarray:
     """block the data
 
     Args:
-        x (data): size Nsample, Nexp
+        x (np.ndarray): size (Nsample, Nexp)
         block_size (int): size of the block
+        expand (bool, optional): expand the blocked data to the original size.
+
+    Returns:
+        np.ndarray: blocked data
     """
     nstep, nwalkers = x.shape
     nblock = nstep // block_size
 
-    xb = np.copy(x[:block_size * nblock, :])
+    xb = np.copy(x[: block_size * nblock, :])
     xb = xb.reshape(nblock, block_size, nwalkers).mean(axis=1)
 
     if expand:
@@ -21,20 +30,22 @@ def blocking(x, block_size, expand=False):
     return xb
 
 
-def correlation_coefficient(x, norm=True):
-    """Computes the correlation coefficient
+def correlation_coefficient(x: np.ndarray, norm: bool = True) -> np.ndarray:
+    """Computes the correlation coefficient using the FFT
 
     Args:
-        x (np.ndarray): measurement of size [Nsample, Nexperiments]
-        norm (bool, optional): [description]. Defaults to True.
+        x (np.ndarray): Measurement of size [MC steps, N walkers].
+        norm (bool, optional): If True, normalizes the correlation coefficients.
+            Defaults to True.
+
+    Returns:
+        np.ndarray: The computed correlation coefficients.
     """
 
     N = x.shape[0]
-    xm = x-x.mean(0)
+    xm = x - x.mean(0)
 
-    c = np.zeros_like(x)
-    for tau in range(0, N):
-        c[tau] = 1./(N-tau) * (xm[:N-tau] * xm[tau:]).sum(0)
+    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1 :]
 
     if norm:
         c /= c[0]
@@ -42,32 +53,40 @@ def correlation_coefficient(x, norm=True):
     return c
 
 
-def integrated_autocorrelation_time(correlation_coeff, size_max):
+def integrated_autocorrelation_time(
+    correlation_coeff: np.ndarray, size_max: int
+) -> np.ndarray:
     """Computes the integrated autocorrelation time
 
     Args:
         correlation_coeff (np.ndarray): coeff size Nsample,Nexp
-        size_max (int): max size 
+        size_max (int): max size
+
+    Returns:
+        np.ndarray: The computed integrated autocorrelation time
     """
-    return 1. + 2. * np.cumsum(correlation_coeff[1:size_max], 0)
+    return 1.0 + 2.0 * np.cumsum(correlation_coeff[1:size_max], 0)
 
 
-def fit_correlation_coefficient(coeff):
-    """Fit the correlation coefficient 
+def fit_correlation_coefficient(coeff: np.ndarray) -> Tuple[float, np.ndarray]:
+    """Fit the correlation coefficient
        to get the correlation time.
 
     Args:
         coeff (np.ndarray): correlation coefficient
 
     Returns:
-        float, np.ndarray: correlation time, fitted curve
+        float: correlation time
+        np.ndarray: fitted curve
     """
 
-    def fit_exp(x, y):
+    def fit_exp(x: np.ndarray, y: np.ndarray) -> Tuple[float, np.ndarray]:
         """Fit an exponential to the data."""
-        def func(x, tau):
-            return np.exp(-x/tau)
-        popt, pcov = curve_fit(func, x, y, p0=(1.))
+
+        def func(x: np.ndarray, tau: float) -> np.ndarray:
+            return np.exp(-x / tau)
+
+        popt, _ = curve_fit(func, x, y, p0=(1.0))
         return popt[0], func(x, popt)
 
     return fit_exp(np.arange(len(coeff)), coeff)
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 4848fa74..95e2a946 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,36 +1,47 @@
+from typing import Optional, ContextManager, Tuple
 import torch
 from torch import nn
 from torch.autograd import grad, Variable
 from torch.utils.data import Dataset
+from math import ceil
 
 
-def set_torch_double_precision():
+def set_torch_double_precision() -> None:
     """Set the default precision to double for all torch tensors."""
     torch.set_default_dtype(torch.float64)
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32  = False
     # torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-def set_torch_single_precision():
+def set_torch_single_precision() -> None:
     """Set the default precision to single for all torch tensors."""
     torch.set_default_dtype(torch.float32)
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32  = False
     # torch.set_default_tensor_type(torch.FloatTensor)
 
 
-def fast_power(x, k, mask0=None, mask2=None):
-    """Computes x**k when k have elements 0, 1, 2
+def fast_power(
+    x: torch.Tensor, 
+    k: torch.Tensor, 
+    mask0: Optional[torch.Tensor] = None, 
+    mask2: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+    """
+    Computes x**k when k have elements 0, 1, 2.
 
     Args:
-        x (torch.tensor): input
-        k (torch.tensor): exponents
-        mask0 (torch.tensor): precomputed mask of the elements of that are 0 (Defaults to None and computed here)
-        mask2 (torch.tensor): precomputed mask of the elements of that are 2 (Defaults to None and computed here)
+        x (torch.Tensor): input
+        k (torch.Tensor): exponents
+        mask0 (torch.Tensor): precomputed mask of the elements of that are 0 (Defaults to None and computed here)
+        mask2 (torch.Tensor): precomputed mask of the elements of that are 2 (Defaults to None and computed here)
 
     Returns:
-        torch.tensor: values of x**k
+        torch.Tensor: values of x**k
     """
     kmax = 3
     if k.max() < kmax:
-
         out = x.clone()
 
         if mask0 is None:
@@ -49,32 +60,42 @@ def fast_power(x, k, mask0=None, mask2=None):
     return out
 
 
-def gradients(out, inp):
-    """Return the gradients of out wrt inp
+def gradients(
+    out: torch.Tensor,
+    inp: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Return the gradients of out wrt inp
 
     Args:
-        out ([type]): [description]
-        inp ([type]): [description]
+        out (torch.Tensor): The output tensor
+        inp (torch.Tensor): The input tensor
+
+    Returns:
+        torch.Tensor: Gradient of out wrt inp
     """
     return grad(out, inp, grad_outputs=torch.ones_like(out))
 
 
-def diagonal_hessian(out, inp, return_grads=False):
-    """return the diagonal hessian of out wrt to inp
+def diagonal_hessian(
+        out: torch.Tensor, 
+        inp: torch.Tensor, 
+        return_grads: bool = False
+    ) -> torch.Tensor:
+    """Return the diagonal Hessian of `out` with respect to `inp`.
 
     Args:
-        out ([type]): [description]
-        inp ([type]): [description]
+        out (torch.Tensor): The output tensor.
+        inp (torch.Tensor): The input tensor.
+        return_grads (bool, optional): Whether to return gradients. Defaults to False.
 
     Returns:
-        [type]: [description]
+        torch.Tensor: Diagonal elements of the Hessian.
+        torch.Tensor (optional): Gradients of `out` with respect to `inp` if `return_grads` is True.
     """
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     if return_grads:
         grads = jacob.detach()
@@ -84,11 +105,9 @@ def diagonal_hessian(out, inp, return_grads=False):
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], inp,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], inp, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -100,16 +119,14 @@ def diagonal_hessian(out, inp, return_grads=False):
 
 
 class DataSet(Dataset):
-
-    def __init__(self, data):
+    def __init__(self, data: torch.Tensor) -> None:
         """Creates a torch data set
 
         Arguments:
-            data {torch.tensor} -- data
+            data (torch.Tensor): data
         """
-        self.data = data
 
-    def __len__(self):
+    def __len__(self) -> int:
         """get the number of data points
 
         Returns:
@@ -117,7 +134,7 @@ def __len__(self):
         """
         return self.data.shape[0]
 
-    def __getitem__(self, index):
+    def __getitem__(self, index: int) -> torch.Tensor:
         """returns a given data point
 
         Arguments:
@@ -129,153 +146,57 @@ def __getitem__(self, index):
         return self.data[index, :]
 
 
-class Loss(nn.Module):
-
+class DataLoader:
     def __init__(
-            self,
-            wf,
-            method='energy',
-            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: {'energy'})
-                            (energy, variance, weighted-energy,
-                            weighted-variance)
-            clip {bool} -- clip the values that are +/- % sigma away from
-                           the mean (default: {False})
+        self, data: torch.Tensor, 
+        batch_size: int, 
+        pin_memory: bool = False
+    ) -> None:
+        """Simple DataLoader to replace torch data loader
+
+        Args:
+            data (torch.Tensor): data to load [Nbatch,Nelec*3]
+            batch_size (int): size of the minibatch
+            pin_memory (bool, optional): copy the data to pinned memory. Defaults to False.
         """
 
-        super(Loss, self).__init__()
-
-        self.wf = wf
-        self.method = method
-        self.clip = clip
-
-        # by default we use weights
-        # that are needed if we do
-        # not resample at every time step
-        self.use_weight = True
-
-        # number of +/- std for clipping
-        # Excludes values + /- Nstd x std the mean of the eloc
-        self.clip_num_std = 5
-
-        # select loss function
-        self.loss_fn = {'energy': torch.mean,
-                        'variance': torch.var}[method]
-
-        # init values of the weights
-        self.weight = {'psi': None, 'psi0': None}
-
-    def forward(self, pos, no_grad=False, deactivate_weight=False):
-        """Computes the loss
+        if pin_memory:
+            self.dataset = data.pin_memory()
+        else:
+            self.dataset = data
 
-        Arguments:
-            pos {torch.tensor} -- positions of the walkers in that batch
+        self.len = len(data)
+        self.nbatch = ceil(self.len / batch_size)
+        self.count = 0
+        self.batch_size = batch_size
 
-        Keyword Arguments:
-            no_grad {bool} -- computes the gradient of the loss
-                              (default: {False})
+    def __iter__(self):
+        """Initialize the iterator.
 
         Returns:
-            torch.tensor, torch.tensor -- value of the loss, local energies
-        """
-
-        # check if grads are requested
-        with self.get_grad_mode(no_grad):
-
-            # compute local eneergies
-            local_energies = self.wf.local_energy(pos)
-
-            # mask the energies if necessary
-            mask = self.get_clipping_mask(local_energies)
-
-            # sampling_weight
-            weight = self.get_sampling_weights(pos, deactivate_weight)
-
-            # compute the loss
-            loss = self.loss_fn((weight * local_energies)[mask])
-
-        return loss, local_energies
-
-    @staticmethod
-    def get_grad_mode(no_grad):
-        """Returns enable_grad or no_grad
-
-        Arguments:
-            no_grad {bool} -- [description]
+            DataLoader: The iterator instance.
         """
+        self.count = 0
+        return self
 
-        return torch.no_grad() if no_grad else torch.enable_grad()
+    def __next__(self) -> torch.Tensor:
+        """Returns the next batch of data points.
 
-    def get_clipping_mask(self, local_energies):
-        """computes the clipping mask
+        Returns:
+            torch.Tensor: The next batch of data points.
 
-        Arguments:
-            local_energies {torch.tensor} -- values of the local energies
+        Raises:
+            StopIteration: If there are no more batches to return.
         """
-        if self.clip:
-            median = torch.median(local_energies)
-            std = torch.std(local_energies)
-            emax = median + self.clip_num_std * std
-            emin = median - self.clip_num_std * std
-            mask = (
-                local_energies < emax) & (
-                local_energies > emin)
+        if self.count < self.nbatch - 1:
+            out = self.dataset[
+                self.count * self.batch_size : (self.count + 1) * self.batch_size
+            ]
+            self.count += 1
+            return out
+        elif self.count == self.nbatch - 1:
+            out = self.dataset[self.count * self.batch_size :]
+            self.count += 1
+            return out
         else:
-            mask = torch.ones_like(
-                local_energies).type(torch.bool)
-
-        return mask
-
-    def get_sampling_weights(self, pos, deactivate_weight):
-        """Get the weight needed when resampling is not
-            done at every step
-        """
-
-        local_use_weight = self.use_weight * \
-            (not deactivate_weight)
-
-        if local_use_weight:
-
-            # computes the weights
-            self.weight['psi'] = self.wf(pos)
-
-            # if we just resampled store psi and all w=1
-            if self.weight['psi0'] is None:
-                self.weight['psi0'] = self.weight['psi'].detach(
-                ).clone()
-                w = torch.ones_like(self.weight['psi'])
-
-            # otherwise compute ration of psi
-            else:
-                w = (self.weight['psi'] / self.weight['psi0'])**2
-                w /= w.sum()  # should we multiply by the number of elements ?
-
-            return w
-
-        else:
-            return 1.
-
-
-class OrthoReg(nn.Module):
-    '''add a penalty to make matrice orthgonal.'''
-
-    def __init__(self, alpha=0.1):
-        """Add a penalty loss to keep the MO orthogonalized
-
-        Keyword Arguments:
-            alpha {float} -- strength of the penaly (default: {0.1})
-        """
-        super(OrthoReg, self).__init__()
-        self.alpha = alpha
-
-    def forward(self, W):
-        """Return the loss : |W x W^T - I|."""
-        return self.alpha * \
-            torch.norm(W.mm(W.transpose(0, 1)) -
-                       torch.eye(W.shape[0]))
+            raise StopIteration
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 10d3688b..b234afcc 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,10 +1,5 @@
-__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterManyBodyJastrow',
-           'SlaterJastrowBackFlow', 'SlaterOrbitalDependentJastrow',
-           'SlaterManyBodyJastrowBackflow']
-
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-from .slater_combined_jastrow import SlaterManyBodyJastrow
-from .slater_jastrow_backflow import SlaterJastrowBackFlow
-from .slater_combined_jastrow_backflow import SlaterManyBodyJastrowBackflow
 from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
+
+__all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
new file mode 100644
index 00000000..79486229
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -0,0 +1,161 @@
+from torch import nn
+from functools import reduce
+
+
+class CombineJastrow(nn.Module):
+    def __init__(self, jastrow):
+        """[summary]
+
+        Args:
+            jastrow (list) : list of jastrow factor
+        """
+
+        super().__init__()
+
+        self.jastrow_terms = nn.ModuleList()
+        for j in jastrow:
+            self.jastrow_terms.append(j)
+
+        self.requires_autograd = True
+
+        self.nterms = len(self.jastrow_terms)
+
+    def __repr__(self):
+        """representation of the jastrow factor"""
+        out = []
+        for term in self.jastrow_terms:
+            out.append(term.jastrow_kernel.__class__.__name__)
+
+        return " + ".join(out)
+
+    def forward(self, pos, derivative=0, sum_grad=True):
+        """Compute the Jastrow factors.
+
+        Args:
+            pos(torch.tensor): Positions of the electrons
+               Size: Nbatch, Nelec x Ndim
+            derivative (int, optional): order of the derivative (0, 1, 2,).
+              Defaults to 0.
+            sum_grad(bool, optional): Return the sum_grad(i.e. the sum of
+                                                           the derivatives)
+              terms. Defaults to True.
+                False only for derivative = 1
+
+        Returns:
+            torch.tensor: value of the jastrow parameter for all confs
+              derivative = 0  (Nmo) x Nbatch x 1
+               derivative = 1  (Nmo) x Nbatch x Nelec
+                  (for sum_grad = True)
+                derivative = 1  (Nmo) x Nbatch x Ndim x Nelec
+                  (for sum_grad = False)
+        """
+        if derivative == 0:
+            jast_vals = [term(pos) for term in self.jastrow_terms]
+            return self.get_combined_values(jast_vals)
+
+        elif derivative == 1:
+            if sum_grad:
+                jast_vals = [term(pos) for term in self.jastrow_terms]
+            else:
+                jast_vals = [term(pos).unsqueeze(-1) for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=sum_grad)
+                for term in self.jastrow_terms
+            ]
+
+            return self.get_derivative_combined_values(jast_vals, djast_vals)
+
+        elif derivative == 2:
+            jast_vals = [term(pos) for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=False) for term in self.jastrow_terms
+            ]
+            d2jast_vals = [term(pos, derivative=2) for term in self.jastrow_terms]
+            return self.get_second_derivative_combined_values(
+                jast_vals, djast_vals, d2jast_vals
+            )
+
+        elif derivative == [0, 1, 2]:
+            jast_vals = [term(pos) for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=False) for term in self.jastrow_terms
+            ]
+            d2jast_vals = [term(pos, derivative=2) for term in self.jastrow_terms]
+
+            # combine the jastrow terms
+            out_jast = self.get_combined_values(jast_vals)
+
+            # combine the second derivative
+            out_d2jast = self.get_second_derivative_combined_values(
+                jast_vals, djast_vals, d2jast_vals
+            )
+
+            # unsqueeze the jast terms to be compatible with the
+            # derivative
+            jast_vals = [j.unsqueeze(-1) for j in jast_vals]
+
+            # combine the derivative
+            out_djast = self.get_derivative_combined_values(jast_vals, djast_vals)
+
+            return (out_jast, out_djast, out_d2jast)
+
+        else:
+            raise ValueError("derivative not understood")
+
+    @staticmethod
+    def get_combined_values(jast_vals):
+        """Compute the product of all terms in jast_vals."""
+        if len(jast_vals) == 1:
+            return jast_vals[0]
+        else:
+            return reduce(lambda x, y: x * y, jast_vals)
+
+    @staticmethod
+    def get_derivative_combined_values(jast_vals, djast_vals):
+        """Compute the derivative of the product.
+        .. math:
+            J = A * B * C
+            \\frac{d J}{dx} = \\frac{d A}{dx} B C + A \\frac{d B}{dx} C + A B \\frac{d C}{dx}
+        """
+        if len(djast_vals) == 1:
+            return djast_vals[0]
+        else:
+            out = 0.0
+            nterms = len(jast_vals)
+            for i in range(nterms):
+                tmp = jast_vals.copy()
+                tmp[i] = djast_vals[i]
+                out += reduce(lambda x, y: x * y, tmp)
+            return out
+
+    @staticmethod
+    def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
+        """Compute the derivative of the product.
+        .. math:
+            J = A * B * C
+            \\frac{d^2 J}{dx^2} = \\frac{d^2 A}{dx^2} B C + A \\frac{d^2 B}{dx^2} C + A B \\frac{d^2 C}{dx^2} \\
+                               + 2( \\frac{d A}{dx} \\frac{dB}{dx} C + \\frac{d A}{dx} B \\frac{dC}{dx} + A \\frac{d B}{dx} \\frac{dC}{dx} )
+        """
+        if len(d2jast_vals) == 1:
+            return d2jast_vals[0]
+
+        # otherwise
+        out = 0.0
+        nterms = len(jast_vals)
+        for i in range(nterms):
+            # d2a * b * c
+            tmp = jast_vals.copy()
+            tmp[i] = d2jast_vals[i]
+            out = out + reduce(lambda x, y: x * y, tmp)
+
+        for i in range(nterms - 1):
+            for j in range(i + 1, nterms):
+                # da * db * c
+                tmp = jast_vals.copy()
+                tmp = [j.unsqueeze(-1) for j in tmp]
+                tmp[i] = djast_vals[i]
+                tmp[j] = djast_vals[j]
+
+                out = out + (2.0 * reduce(lambda x, y: x * y, tmp)).sum(1)
+
+        return out
diff --git a/qmctorch/wavefunction/jastrows/distance/__init__.py b/qmctorch/wavefunction/jastrows/distance/__init__.py
index a34c958e..27961cb8 100644
--- a/qmctorch/wavefunction/jastrows/distance/__init__.py
+++ b/qmctorch/wavefunction/jastrows/distance/__init__.py
@@ -1,2 +1,4 @@
 from .electron_electron_distance import ElectronElectronDistance
 from .electron_nuclei_distance import ElectronNucleiDistance
+
+__all__ = ["ElectronElectronDistance", "ElectronNucleiDistance"]
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 3b6fbd3a..df95a16f 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -1,13 +1,19 @@
 import torch
 from torch import nn
-from .scaling import (get_scaled_distance,
-                      get_der_scaled_distance,
-                      get_second_der_scaled_distance)
+from .scaling import (
+    get_scaled_distance,
+    get_der_scaled_distance,
+    get_second_der_scaled_distance,
+)
 
 
 class ElectronElectronDistance(nn.Module):
-
-    def __init__(self, nelec, ndim=3, scale=False, scale_factor=0.6):
+    def __init__(self, 
+                 nelec: int, 
+                 ndim: int = 3, 
+                 scale: bool = False,
+                 scale_factor: float = 0.6
+                 ) -> None:
         """Computes the electron-electron distances
 
         .. math::
@@ -15,10 +21,11 @@ def __init__(self, nelec, ndim=3, scale=False, scale_factor=0.6):
 
         Args:
             nelec (int): number of electrons
-            ndim (int): number of spatial dimensions
-            scale(bool, optional): return scaled values, Defaults to False
-            scale_factor(float, optional): value of the scale factor,
-                                           Defaults to 0.6
+            ndim (int, optional): number of spatial dimensions.
+                Defaults to 3.
+            scale (bool, optional): return scaled values. Defaults to False.
+            scale_factor (float, optional): value of the scale factor.
+                Defaults to 0.6.
 
         Examples::
             >>> edist = ElectronDistance(2,3)
@@ -36,13 +43,17 @@ def __init__(self, nelec, ndim=3, scale=False, scale_factor=0.6):
 
         _type_ = torch.get_default_dtype()
         if _type_ == torch.float32:
-            self.eps = 1E-6
+            self.eps = 1e-6
         elif _type_ == torch.float64:
-            self.eps = 1E-16
+            self.eps = 1e-16
 
-    def forward(self, input, derivative=0):
+    def forward(
+        self, 
+        input: torch.Tensor, 
+        derivative: int = 0
+    ) -> torch.Tensor:
         """Compute the pairwise distance between the electrons
-        or its derivative. \n
+        or its derivative.
 
         When required, the derivative is computed wrt to the first electron i.e.
 
@@ -55,14 +66,14 @@ def forward(self, input, derivative=0):
             \\frac{d r_{ij}}{dx_j} = -\\frac{dr_{ij}}{dx_i}
 
         Args:
-            input (torch.tesnor): position of the electron \n
+            input (torch.Tensor): position of the electron 
                                   size : Nbatch x [Nelec x Ndim]
-            derivative (int, optional): degre of the derivative. \n
+            derivative (int, optional): degre of the derivative. 
                                         Defaults to 0.
 
         Returns:
-            torch.tensor: distance (or derivative) matrix \n
-                          Nbatch x Nelec x Nelec if derivative = 0 \n
+            torch.Tensor: distance (or derivative) matrix 
+                          Nbatch x Nelec x Nelec if derivative = 0 
                           Nbatch x Ndim x  Nelec x Nelec if derivative = 1,2
 
         """
@@ -79,7 +90,6 @@ def forward(self, input, derivative=0):
                 return dist
 
         elif derivative == 1:
-
             der_dist = self.get_der_distance(input_, dist)
 
             if self.scale:
@@ -88,19 +98,17 @@ def forward(self, input, derivative=0):
                 return der_dist
 
         elif derivative == 2:
-
             d2_dist = self.get_second_der_distance(input_, dist)
 
             if self.scale:
                 der_dist = self.get_der_distance(input_, dist)
-                return get_second_der_scaled_distance(self.kappa,
-                                                      dist,
-                                                      der_dist,
-                                                      d2_dist)
+                return get_second_der_scaled_distance(
+                    self.kappa, dist, der_dist, d2_dist
+                )
             else:
                 return d2_dist
 
-    def safe_sqrt(self, dist):
+    def safe_sqrt(self, dist: torch.Tensor) -> torch.Tensor:
         """Compute the square root of the electron electron distance matrix.
 
         Args:
@@ -113,21 +121,18 @@ def safe_sqrt(self, dist):
         """
 
         # epsilon on the diag needed for back prop
-        eps_ = self.eps * \
-            torch.diag(dist.new_ones(dist.shape[-1])).expand_as(dist)
+        eps_ = self.eps * torch.diag(dist.new_ones(dist.shape[-1])).expand_as(dist)
 
         # extact the diagonal as diag can be negative someties
         # due to numerical noise
-        diag = torch.diag_embed(
-            torch.diagonal(
-                dist, dim1=-1, dim2=-2))
+        diag = torch.diag_embed(torch.diagonal(dist, dim1=-1, dim2=-2))
 
         # remove diagonal and add eps for backprop
         dist = torch.sqrt(dist - diag + eps_)
 
         return dist
 
-    def get_der_distance(self, pos, dist):
+    def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
         """Get the derivative of the electron electron distance matrix.
 
         .. math::
@@ -143,16 +148,14 @@ def get_der_distance(self, pos, dist):
             [type]: [description]
         """
 
-        eps_ = self.eps * \
-            torch.diag(dist.new_ones(
-                dist.shape[-1])).expand_as(dist)
+        eps_ = self.eps * torch.diag(dist.new_ones(dist.shape[-1])).expand_as(dist)
 
-        invr = (1. / (dist + eps_)).unsqueeze(1)
+        invr = (1.0 / (dist + eps_)).unsqueeze(1)
         diff_axis = pos.transpose(1, 2).unsqueeze(3)
         diff_axis = diff_axis - diff_axis.transpose(2, 3)
         return diff_axis * invr
 
-    def get_second_der_distance(self, pos, dist):
+    def get_second_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
         """Get the second derivative of the electron electron distance matrix.
 
         .. math::
@@ -168,19 +171,16 @@ def get_second_der_distance(self, pos, dist):
             [type]: [description]
         """
 
-        eps_ = self.eps * \
-            torch.diag(dist.new_ones(
-                dist.shape[-1])).expand_as(dist)
-        invr3 = (1. / (dist**3 + eps_)).unsqueeze(1)
+        eps_ = self.eps * torch.diag(dist.new_ones(dist.shape[-1])).expand_as(dist)
+        invr3 = (1.0 / (dist**3 + eps_)).unsqueeze(1)
         diff_axis = pos.transpose(1, 2).unsqueeze(3)
-        diff_axis = (diff_axis - diff_axis.transpose(2, 3))**2
+        diff_axis = (diff_axis - diff_axis.transpose(2, 3)) ** 2
 
-        diff_axis = diff_axis[:, [
-            [1, 2], [2, 0], [0, 1]], ...].sum(2)
-        return (diff_axis * invr3)
+        diff_axis = diff_axis[:, [[1, 2], [2, 0], [0, 1]], ...].sum(2)
+        return diff_axis * invr3
 
     @staticmethod
-    def get_distance_quadratic(pos):
+    def get_distance_quadratic(pos: torch.Tensor) -> torch.Tensor:
         """Compute the distance following a quadratic expansion
 
         Arguments:
@@ -191,12 +191,11 @@ def get_distance_quadratic(pos):
         """
 
         norm = (pos**2).sum(-1).unsqueeze(-1)
-        dist = (norm + norm.transpose(1, 2) - 2.0 *
-                torch.bmm(pos, pos.transpose(1, 2)))
+        dist = norm + norm.transpose(1, 2) - 2.0 * torch.bmm(pos, pos.transpose(1, 2))
         return dist
 
     @staticmethod
-    def get_difference(pos):
+    def get_difference(pos: torch.Tensor) -> torch.Tensor:
         """Compute the difference ri - rj
 
         Arguments:
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index ea4a67f4..20b0cbee 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,13 +1,22 @@
 import torch
 from torch import nn
-from .scaling import (get_scaled_distance,
-                      get_der_scaled_distance,
-                      get_second_der_scaled_distance)
+from typing import Optional, Tuple, Union
+from .scaling import (
+    get_scaled_distance,
+    get_der_scaled_distance,
+    get_second_der_scaled_distance,
+)
 
 
 class ElectronNucleiDistance(nn.Module):
-
-    def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
+    def __init__(
+        self,
+        nelec: int,
+        atomic_pos: torch.Tensor,
+        ndim: int = 3,
+        scale: bool = False,
+        scale_factor: float = 0.6,
+    ) -> None:
         """Computes the electron-nuclei distances
 
         .. math::
@@ -15,7 +24,7 @@ def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
 
         Args:
             nelec (int): number of electrons
-            atomic_pos (tensor): positions of the atoms
+            atomic_pos (torch.tensor): positions of the atoms
             ndim (int): number of spatial dimensions
             scale(bool, optional): return scaled values, Defaults to False
             scale_factor(float, optional): value of the scale factor,
@@ -28,28 +37,30 @@ def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
             >>> dr = edist(pos,derivative=1)
 
         """
-
         super().__init__()
-        self.nelec = nelec
-        self.atoms = atomic_pos
-        self.ndim = ndim
-        self.scale = scale
-        self.kappa = scale_factor
-
-    def forward(self, input, derivative=0):
+        self.nelec: int = nelec
+        self.atoms: torch.Tensor = atomic_pos
+        self.ndim: int = ndim
+        self.scale: bool = scale
+        self.kappa: float = scale_factor
+
+    def forward(
+        self, input: torch.Tensor, derivative: int = 0
+    ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
         """Compute the pairwise distances between electrons and atoms
         or their derivative.
 
         Args:
-            input (torch.tesnor): position of the electron \n
+            input (torch.Tensor): position of the electron \n
                                   size : Nbatch x [Nelec x Ndim]
             derivative (int, optional): degre of the derivative. \n
                                         Defaults to 0.
 
         Returns:
-            torch.tensor: distance (or derivative) matrix \n
-                          Nbatch x Nelec x Natom if derivative = 0 \n
-                          Nbatch x Ndim x  Nelec x Natom if derivative = 1,2
+            Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+                distance (or derivative) matrix \n
+                Nbatch x Nelec x Natom if derivative = 0 \n
+                Nbatch x Ndim x  Nelec x Natom if derivative = 1,2
 
         """
 
@@ -58,7 +69,7 @@ def forward(self, input, derivative=0):
         dist = self._get_distance_quadratic(input_, self.atoms)
         dist = torch.sqrt(dist)
 
-        if derivative == 0:
+        if derivative == 0:  # pylint: disable=no-else-return
             if self.scale:
                 return get_scaled_distance(self.kappa, dist)
             else:
@@ -67,25 +78,22 @@ def forward(self, input, derivative=0):
         elif derivative == 1:
             der_dist = self.get_der_distance(input_, dist)
             if self.scale:
-                return get_der_scaled_distance(self.kappa,
-                                               dist, der_dist)
+                return get_der_scaled_distance(self.kappa, dist, der_dist)
             else:
                 return der_dist
 
         elif derivative == 2:
-
             d2_dist = self.get_second_der_distance(input_, dist)
 
             if self.scale:
                 der_dist = self.get_der_distance(input_, dist)
-                return get_second_der_scaled_distance(self.kappa,
-                                                      dist,
-                                                      der_dist,
-                                                      d2_dist)
+                return get_second_der_scaled_distance(
+                    self.kappa, dist, der_dist, d2_dist
+                )
             else:
                 return d2_dist
 
-    def get_der_distance(self, pos, dist):
+    def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
         """Get the derivative of the electron-nuclei distance matrix
 
         .. math::
@@ -101,12 +109,11 @@ def get_der_distance(self, pos, dist):
         Returns:
             [type]: [description]
         """
-        invr = (1. / dist).unsqueeze(-1)
-        diff_axis = (pos.unsqueeze(-1) -
-                     self.atoms.T).transpose(2, 3)
+        invr = (1.0 / dist).unsqueeze(-1)
+        diff_axis = (pos.unsqueeze(-1) - self.atoms.T).transpose(2, 3)
         return (diff_axis * invr).permute(0, 3, 1, 2)
 
-    def get_second_der_distance(self, pos, dist):
+    def get_second_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
         """Get the derivative of the electron-nuclei distance matrix
 
         .. math::
@@ -121,17 +128,16 @@ def get_second_der_distance(self, pos, dist):
         Returns:
             [type]: [description]
         """
-        invr3 = (1. / (dist**3)).unsqueeze(1)
+        invr3 = (1.0 / (dist**3)).unsqueeze(1)
         diff_axis = pos.transpose(1, 2).unsqueeze(3)
-        diff_axis = (diff_axis - self.atoms.T.unsqueeze(1))**2
+        diff_axis = (diff_axis - self.atoms.T.unsqueeze(1)) ** 2
 
-        diff_axis = diff_axis[:, [
-            [1, 2], [2, 0], [0, 1]], ...].sum(2)
+        diff_axis = diff_axis[:, [[1, 2], [2, 0], [0, 1]], ...].sum(2)
 
-        return (diff_axis * invr3)
+        return diff_axis * invr3
 
     @staticmethod
-    def _get_distance_quadratic(elec_pos, atom_pos):
+    def _get_distance_quadratic(elec_pos: torch.Tensor, atom_pos: torch.Tensor) -> torch.Tensor:
         """Compute the distance following a quadratic expansion
 
         Arguments:
@@ -142,5 +148,5 @@ def _get_distance_quadratic(elec_pos, atom_pos):
         """
         norm = (elec_pos**2).sum(-1).unsqueeze(-1)
         norm_atom = (atom_pos**2).sum(-1).unsqueeze(-1).T
-        dist = (norm + norm_atom - 2.0 * elec_pos@atom_pos.T)
+        dist = norm + norm_atom - 2.0 * elec_pos @ atom_pos.T
         return dist
diff --git a/qmctorch/wavefunction/jastrows/distance/scaling.py b/qmctorch/wavefunction/jastrows/distance/scaling.py
index 216f5c79..6c39e1c0 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -1,7 +1,7 @@
 import torch
 
 
-def get_scaled_distance(kappa, r):
+def get_scaled_distance(kappa: float, r: torch.Tensor) -> torch.Tensor:
     """compute the scaled distance
 
     .. math::
@@ -16,10 +16,10 @@ def get_scaled_distance(kappa, r):
         torch.tensor: values of the scaled distance
                         Nbatch, Nelec, Nelec
     """
-    return (1. - torch.exp(-kappa * r))/kappa
+    return (1.0 - torch.exp(-kappa * r)) / kappa
 
 
-def get_der_scaled_distance(kappa, r, dr):
+def get_der_scaled_distance(kappa: float, r:torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
     """Returns the derivative of the scaled distances
 
     .. math::
@@ -39,7 +39,7 @@ def get_der_scaled_distance(kappa, r, dr):
     return dr * torch.exp(-kappa * r.unsqueeze(1))
 
 
-def get_second_der_scaled_distance(kappa, r, dr, d2r):
+def get_second_der_scaled_distance(kappa: float, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
     """computes the second derivative of the scaled distances
 
     .. math::
@@ -59,4 +59,4 @@ def get_second_der_scaled_distance(kappa, r, dr, d2r):
         torch.tensor : second deriative of the scaled distance
                         Nbatch x Ndim x Nelec x Nelec
     """
-    return (d2r - kappa * dr * dr) * torch.exp(-kappa*r.unsqueeze(1))
+    return (d2r - kappa * dr * dr) * torch.exp(-kappa * r.unsqueeze(1))
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index e69de29b..43261d1d 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -0,0 +1,13 @@
+from .jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron as JastrowFactor,
+)
+from .kernels.pade_jastrow_kernel import PadeJastrowKernel
+from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from .kernels.pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
+
+__all__ = [
+    "JastrowFactor",
+    "PadeJastrowKernel",
+    "FullyConnectedJastrowKernel",
+    "PadeJastrowPolynomialKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
index 16ddad2d..e56a850d 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -1,18 +1,23 @@
 import torch
 from torch import nn
+from typing import Optional, Dict, Union, Tuple
 from ..distance.electron_electron_distance import ElectronElectronDistance
 from .orbital_dependent_jastrow_kernel import OrbitalDependentJastrowKernel
-
+from .kernels.jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
+from ....scf import Molecule
 
 class JastrowFactorElectronElectron(nn.Module):
-
-    def __init__(self, nup, ndown,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 orbital_dependent_kernel=False,
-                 number_of_orbitals=None,
-                 scale=False, scale_factor=0.6,
-                 cuda=False):
+    def __init__(
+        self,
+        mol: Molecule,
+        jastrow_kernel: JastrowKernelElectronElectronBase,
+        kernel_kwargs: Optional[Dict] = {},
+        orbital_dependent_kernel: Optional[bool] = False,
+        number_of_orbitals: Optional[Union[int, None]] = None,
+        scale: Optional[bool]=False,
+        scale_factor: Optional[float]=0.6,
+        cuda: Optional[bool]=False,
+    ) -> None:
         """Electron-Electron Jastrow factor.
 
         .. math::
@@ -26,52 +31,68 @@ def __init__(self, nup, ndown,
             orbital_dependent_kernel (bool, optional): Make the kernel orbital dependent. Defaults to False.
             number_of_orbitals (int, optional): number of orbitals for orbital dependent kernels. Defaults to None.
             scale (bool, optional): use scaled electron-electron distance. Defaults to False.
-            scale_factor (float, optional): scaling factor. Defaults to 0.6.
+            scale_factor (float, optional): scaling factor for elec-elec distance. Defaults to 0.6.
             cuda (bool, optional): use cuda. Defaults to False.
         """
 
         super().__init__()
 
-        self.nup = nup
-        self.ndown = ndown
-        self.nelec = nup + ndown
+        self.nup = mol.nup
+        self.ndown = mol.ndown
+        self.nelec = mol.nup + mol.ndown
         self.ndim = 3
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
         self.requires_autograd = True
 
         # kernel function
         if orbital_dependent_kernel:
+            # default to all orbitals if number_of_orbitals is None
+            if number_of_orbitals is None:
+                number_of_orbitals = mol.basis.nmo
+            # create the orbital dependent jastrow
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
-                nup, ndown, number_of_orbitals, cuda, jastrow_kernel, kernel_kwargs)
+                mol.nup,
+                mol.ndown,
+                number_of_orbitals,
+                cuda,
+                jastrow_kernel,
+                kernel_kwargs,
+            )
         else:
             self.jastrow_kernel = jastrow_kernel(
-                nup, ndown, cuda, **kernel_kwargs)
+                mol.nup, mol.ndown, cuda, **kernel_kwargs
+            )
             self.requires_autograd = self.jastrow_kernel.requires_autograd
 
         # mask to extract the upper diag of the matrices
         self.mask_tri_up, self.index_col, self.index_row = self.get_mask_tri_up()
 
         # elec-elec distances
-        self.edist = ElectronElectronDistance(self.nelec, self.ndim,
-                                              scale=scale,
-                                              scale_factor=scale_factor)
+        self.edist = ElectronElectronDistance(
+            self.nelec, self.ndim, scale=scale, scale_factor=scale_factor
+        )
 
-    def get_mask_tri_up(self):
-        r"""Get the mask to select the triangular up matrix
+    def __repr__(self) -> str:
+        """representation of the jastrow factor"""
+        return "ee -> " + self.jastrow_kernel.__class__.__name__
+
+    def get_mask_tri_up(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Get the mask to select the triangular up matrix
 
         Returns:
-            torch.tensor: mask of the tri up matrix
+            mask (torch.Tensor): mask of the tri up matrix, shape (nelec, nelec)
+            index_col (torch.Tensor): long tensor of the column index, shape (-1,)
+            index_row (torch.Tensor): long tensor of the row index, shape (-1,)
         """
-        mask = torch.zeros(self.nelec, self.nelec).type(
-            torch.bool).to(self.device)
+        mask = torch.zeros(self.nelec, self.nelec).type(torch.bool).to(self.device)
         index_col, index_row = [], []
-        for i in range(self.nelec-1):
-            for j in range(i+1, self.nelec):
+        for i in range(self.nelec - 1):
+            for j in range(i + 1, self.nelec):
                 index_row.append(i)
                 index_col.append(j)
                 mask[i, j] = True
@@ -80,7 +101,7 @@ def get_mask_tri_up(self):
         index_row = torch.LongTensor(index_row).to(self.device)
         return mask, index_col, index_row
 
-    def extract_tri_up(self, inp):
+    def extract_tri_up(self, inp: torch.Tensor) -> torch.Tensor:
         r"""extract the upper triangular elements
 
         Args:
@@ -92,7 +113,7 @@ def extract_tri_up(self, inp):
         nbatch = inp.shape[0]
         return inp.masked_select(self.mask_tri_up).view(nbatch, -1)
 
-    def get_edist_unique(self, pos, derivative=0):
+    def get_edist_unique(self, pos: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         """Get the unique elements of the electron-electron distance matrix.
 
         Args:
@@ -108,15 +129,21 @@ def get_edist_unique(self, pos, derivative=0):
 
         elif derivative == 1:
             nbatch = pos.shape[0]
-            return self.extract_tri_up(self.edist(
-                pos, derivative=1)).view(nbatch, 3, -1)
+            return self.extract_tri_up(self.edist(pos, derivative=1)).view(
+                nbatch, 3, -1
+            )
 
         elif derivative == 2:
             nbatch = pos.shape[0]
-            return self.extract_tri_up(self.edist(
-                pos, derivative=2)).view(nbatch, 3, -1)
-
-    def forward(self, pos, derivative=0, sum_grad=True):
+            return self.extract_tri_up(self.edist(pos, derivative=2)).view(
+                nbatch, 3, -1
+            )
+
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: int = 0, 
+                sum_grad: bool = True
+                ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
         """Compute the Jastrow factors.
 
         Args:
@@ -152,23 +179,22 @@ def forward(self, pos, derivative=0, sum_grad=True):
             return self.jastrow_factor_derivative(r, dr, jast, sum_grad)
 
         elif derivative == 2:
-
             dr = self.get_edist_unique(pos, derivative=1)
             d2r = self.get_edist_unique(pos, derivative=2)
 
             return self.jastrow_factor_second_derivative(r, dr, d2r, jast)
 
         elif derivative == [0, 1, 2]:
-
             dr = self.get_edist_unique(pos, derivative=1)
             d2r = self.get_edist_unique(pos, derivative=2)
 
-            return(jast,
-                   self.jastrow_factor_derivative(
-                       r, dr, jast, sum_grad),
-                   self.jastrow_factor_second_derivative(r, dr, d2r, jast))
+            return (
+                jast,
+                self.jastrow_factor_derivative(r, dr, jast, sum_grad),
+                self.jastrow_factor_second_derivative(r, dr, d2r, jast),
+            )
 
-    def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
+    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
         """Compute the value of the derivative of the Jastrow factor
 
         Args:
@@ -184,9 +210,7 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
         """
 
         if sum_grad:
-
-            djast = self.jastrow_kernel.compute_derivative(
-                r, dr).sum(-2)
+            djast = self.jastrow_kernel.compute_derivative(r, dr).sum(-2)
             djast = djast * jast
 
             # might cause problems with backward cause in place operation
@@ -196,9 +220,7 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
             out.index_add_(-1, self.index_col, -djast)
 
         else:
-
-            djast = self.jastrow_kernel.compute_derivative(
-                r, dr)
+            djast = self.jastrow_kernel.compute_derivative(r, dr)
             djast = djast * jast.unsqueeze(-1)
 
             # might cause problems with backward cause in place operation
@@ -209,7 +231,7 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
 
         return out
 
-    def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
+    def jastrow_factor_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor, jast: torch.Tensor) -> torch.Tensor:
         """Compute the value of the pure 2nd derivative of the Jastrow factor
 
         Args:
@@ -224,8 +246,7 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
                           Nbatch x Nelec x Ndim
         """
 
-        d2jast = self.jastrow_kernel.compute_second_derivative(
-            r, dr, d2r).sum(-2)
+        d2jast = self.jastrow_kernel.compute_second_derivative(r, dr, d2r).sum(-2)
 
         # might cause problems with backward cause in place operation
         hess_shape = list(d2jast.shape[:-1]) + [self.nelec]
@@ -241,7 +262,7 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
 
         return hess_jast * jast
 
-    def partial_derivative(self, djast):
+    def partial_derivative(self, djast: torch.Tensor) -> torch.Tensor:
         """Computes the partial derivative
 
         Args:
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
index f9413743..189d22f2 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
@@ -2,3 +2,10 @@
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 from .pade_jastrow_kernel import PadeJastrowKernel
 from .pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
+
+__all__ = [
+    "FullyConnectedJastrowKernel",
+    "JastrowKernelElectronElectronBase",
+    "PadeJastrowKernel",
+    "PadeJastrowPolynomialKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/fully_connected_jastrow_kernel.py
index f2b5d55d..57ce8f6c 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/fully_connected_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/fully_connected_jastrow_kernel.py
@@ -1,16 +1,30 @@
 import torch
 from torch import nn
-import numpy as np
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronBase):
+    def __init__(
+        self,
+        nup: int,
+        ndown: int,
+        cuda: bool,
+        size1: int = 16,
+        size2: int = 8,
+        activation: torch.nn.Module = torch.nn.Sigmoid(),
+        include_cusp_weight: bool = True,
+    ) -> None:
+        """Defines a fully connected jastrow factors.
 
-    def __init__(self,  nup, ndown, cuda,
-                 size1=16, size2=8,
-                 activation=torch.nn.Sigmoid(),
-                 include_cusp_weight=True):
-        """Defines a fully connected jastrow factors."""
+        Args:
+            nup (int): Number of spin up electrons.
+            ndown (int): Number of spin down electrons.
+            cuda (bool): Whether to use the GPU or not.
+            size1 (int, optional): Number of neurons in the first hidden layer. Defaults to 16.
+            size2 (int, optional): Number of neurons in the second hidden layer. Defaults to 8.
+            activation (torch.nn.Module, optional): Activation function. Defaults to torch.nn.Sigmoid.
+            include_cusp_weight (bool, optional): Whether to include the cusp weights or not. Defaults to True.
+        """
 
         super().__init__(nup, ndown, cuda)
 
@@ -20,13 +34,13 @@ def __init__(self,  nup, ndown, cuda,
         self.fc2 = nn.Linear(size1, size2, bias=False)
         self.fc3 = nn.Linear(size2, 1, bias=False)
 
-        eps = 1E-6
+        eps = 1e-6
         self.fc1.weight.data *= eps
         self.fc2.weight.data *= eps
         self.fc3.weight.data *= eps
 
         self.nl_func = activation
-        #self.nl_func = lambda x:  x
+        # self.nl_func = lambda x:  x
 
         self.prefac = torch.rand(1)
 
@@ -36,18 +50,17 @@ def __init__(self,  nup, ndown, cuda,
 
         self.include_cusp_weight = include_cusp_weight
 
-    def get_var_weight(self):
+    def get_var_weight(self) -> None:
         """define the variational weight."""
 
         nelec = self.nup + self.ndown
 
-        self.var_cusp_weight = nn.Parameter(
-            torch.as_tensor([0., 0.]))
+        self.var_cusp_weight = nn.Parameter(torch.as_tensor([0.0, 0.0]))
 
         idx_pair = []
-        for i in range(nelec-1):
+        for i in range(nelec - 1):
             ispin = 0 if i < self.nup else 1
-            for j in range(i+1, nelec):
+            for j in range(i + 1, nelec):
                 jspin = 0 if j < self.nup else 1
 
                 if ispin == jspin:
@@ -56,28 +69,41 @@ def get_var_weight(self):
                     idx_pair.append(1)
         self.idx_pair = torch.as_tensor(idx_pair).to(self.device)
 
-    def get_static_weight(self):
+    def get_static_weight(self) -> torch.Tensor:
         """Get the matrix of static weights
 
         Returns:
             torch.tensor: static weight (0.5 (0.25) for parallel(anti) spins
         """
 
-        bup = torch.cat((0.25 * torch.ones(self.nup, self.nup), 0.5 *
-                         torch.ones(self.nup, self.ndown)), dim=1)
-
-        bdown = torch.cat((0.5 * torch.ones(self.ndown, self.nup), 0.25 *
-                           torch.ones(self.ndown, self.ndown)), dim=1)
+        bup = torch.cat(
+            (
+                0.25 * torch.ones(self.nup, self.nup),
+                0.5 * torch.ones(self.nup, self.ndown),
+            ),
+            dim=1,
+        )
+
+        bdown = torch.cat(
+            (
+                0.5 * torch.ones(self.ndown, self.nup),
+                0.25 * torch.ones(self.ndown, self.ndown),
+            ),
+            dim=1,
+        )
 
         static_weight = torch.cat((bup, bdown), dim=0).to(self.device)
 
-        mask_tri_up = torch.triu(torch.ones_like(
-            static_weight), diagonal=1).type(torch.BoolTensor).to(self.device)
+        mask_tri_up = (
+            torch.triu(torch.ones_like(static_weight), diagonal=1)
+            .type(torch.BoolTensor)
+            .to(self.device)
+        )
         static_weight = static_weight.masked_select(mask_tri_up)
 
         return static_weight
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the kernel values
 
         Args:
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/jastrow_kernel_electron_electron_base.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/jastrow_kernel_electron_electron_base.py
index e0d032af..649360a4 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/jastrow_kernel_electron_electron_base.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/jastrow_kernel_electron_electron_base.py
@@ -1,12 +1,10 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-from torch import nn
-
+from typing import Tuple
 
 class JastrowKernelElectronElectronBase(nn.Module):
-
-    def __init__(self, nup, ndown, cuda, **kwargs):
+    def __init__(self, nup: int, ndown: int, cuda: bool, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
 
         Args:
@@ -18,13 +16,13 @@ def __init__(self, nup, ndown, cuda, **kwargs):
         super().__init__()
         self.nup, self.ndown = nup, ndown
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
         self.requires_autograd = True
 
-    def forward(self, r):
+    def forward(self, r: torch.Tensor):
         r"""Get the elements of the jastrow matrix :
 
 
@@ -52,7 +50,7 @@ def forward(self, r):
         """
         raise NotImplementedError()
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels
         wrt to the first electrons using automatic differentiation
 
@@ -67,17 +65,16 @@ def compute_derivative(self, r, dr):
                           Nmo x Nbatch x Ndim x  Nelec_pair
         """
 
-        if r.requires_grad == False:
+        if r.requires_grad is False:
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(self, r, dr, d2r):
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Get the elements of the pure 2nd derivative of the jastrow kernels
         wrt to the first electron using automatic differentiation
 
@@ -101,17 +98,15 @@ def compute_second_derivative(self, r, dr, d2r):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_hess, ker_grad = self._hess(kernel, r)
 
-            jhess = (ker_hess).unsqueeze(1) * \
-                dr2 + ker_grad.unsqueeze(1) * d2r
+            jhess = (ker_hess).unsqueeze(1) * dr2 + ker_grad.unsqueeze(1) * d2r
 
         return jhess
 
     @staticmethod
-    def _grads(val, pos):
+    def _grads(val, pos: torch.Tensor) -> torch.Tensor:
         """Get the gradients of the jastrow values
         of a given orbital terms
 
@@ -124,7 +119,7 @@ def _grads(val, pos):
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(val, pos):
+    def _hess(val: torch.Tensor, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """get the hessian of the jastrow values.
         of a given orbital terms
         Warning thos work only because the orbital term are dependent
@@ -134,10 +129,7 @@ def _hess(val, pos):
             pos ([type]): [description]
         """
 
-        gval = grad(val,
-                    pos,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        gval = grad(val, pos, grad_outputs=torch.ones_like(val), create_graph=True)[0]
 
         hval = grad(gval, pos, grad_outputs=torch.ones_like(gval))[0]
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
index 3d1f4a99..edb1b8f6 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
@@ -6,8 +6,7 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self, nup, ndown, cuda, w=1.):
+    def __init__(self, nup: int, ndown: int, cuda: bool, w: float = 1.0) -> None:
         """Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -26,36 +25,48 @@ def __init__(self, nup, ndown, cuda, w=1.):
 
         super().__init__(nup, ndown, cuda)
 
-        self.weight = nn.Parameter(torch.as_tensor([w]),
-                                   requires_grad=True)
-        register_extra_attributes(self, ['weight'])
+        self.weight = nn.Parameter(torch.as_tensor([w]), requires_grad=True)
+        register_extra_attributes(self, ["weight"])
 
         self.static_weight = self.get_static_weight()
         self.requires_autograd = False
 
-    def get_static_weight(self):
+    def get_static_weight(self) -> torch.Tensor:
         """Get the matrix of static weights
 
         Returns:
             torch.tensor: matrix of the static weights
         """
 
-        bup = torch.cat((0.25 * torch.ones(self.nup, self.nup), 0.5 *
-                         torch.ones(self.nup, self.ndown)), dim=1)
-
-        bdown = torch.cat((0.5 * torch.ones(self.ndown, self.nup), 0.25 *
-                           torch.ones(self.ndown, self.ndown)), dim=1)
+        bup = torch.cat(
+            (
+                0.25 * torch.ones(self.nup, self.nup),
+                0.5 * torch.ones(self.nup, self.ndown),
+            ),
+            dim=1,
+        )
+
+        bdown = torch.cat(
+            (
+                0.5 * torch.ones(self.ndown, self.nup),
+                0.25 * torch.ones(self.ndown, self.ndown),
+            ),
+            dim=1,
+        )
 
         static_weight = torch.cat((bup, bdown), dim=0).to(self.device)
 
-        mask_tri_up = torch.triu(torch.ones_like(
-            static_weight), diagonal=1).type(torch.BoolTensor).to(self.device)
+        mask_tri_up = (
+            torch.triu(torch.ones_like(static_weight), diagonal=1)
+            .type(torch.BoolTensor)
+            .to(self.device)
+        )
         static_weight = static_weight.masked_select(mask_tri_up)
 
         return static_weight
 
-    def forward(self, r):
-        """ Get the jastrow kernel.
+    def forward(self, r: torch.Tensor) -> torch.Tensor:
+        """Get the jastrow kernel.
 
         .. math::
             B_{ij} = \\frac{w_0 r_{i,j}}{1+w r_{i,j}}
@@ -70,7 +81,7 @@ def forward(self, r):
         """
         return self.static_weight * r / (1.0 + self.weight * r)
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels
         wrt to the first electrons
 
@@ -99,13 +110,13 @@ def compute_derivative(self, r, dr):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1. / (1.0 + self.weight * r_)
+        denom = 1.0 / (1.0 + self.weight * r_)
         a = self.static_weight * dr * denom
         b = -self.static_weight * self.weight * r_ * dr * denom**2
 
-        return (a + b)
+        return a + b
 
-    def compute_second_derivative(self, r, dr, d2r):
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Get the elements of the pure 2nd derivative of the jastrow kernels
         wrt to the first electron
 
@@ -128,7 +139,7 @@ def compute_second_derivative(self, r, dr, d2r):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1. / (1.0 + self.weight * r_)
+        denom = 1.0 / (1.0 + self.weight * r_)
         denom2 = denom**2
         dr_square = dr * dr
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_polynomial_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_polynomial_kernel.py
index f67c975c..c61fe142 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_polynomial_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_polynomial_kernel.py
@@ -1,16 +1,13 @@
 import torch
 from torch import nn
-
+from typing import Union, Optional
 from .....utils import register_extra_attributes
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self, nup, ndown, cuda,
-                 order=2,
-                 weight_a=None,
-                 weight_b=None):
+    def __init__(self, nup: int, ndown: int, cuda: bool, order: int = 2, 
+                 weight_a: Union[torch.Tensor, None] = None, weight_b: Union[torch.Tensor, None]=None) -> None:
         """Computes a polynomial Pade-Jastrow factor
 
         .. math::
@@ -44,28 +41,41 @@ def __init__(self, nup, ndown, cuda,
         self.static_weight = self.get_static_weight()
         self.requires_autograd = False
 
-    def get_static_weight(self):
+    def get_static_weight(self) -> torch.Tensor:
         """Get the matrix of static weights
 
         Returns:
             torch.tensor: static weight (0.5 (0.25) for parallel(anti) spins
         """
 
-        bup = torch.cat((0.25 * torch.ones(self.nup, self.nup), 0.5 *
-                         torch.ones(self.nup, self.ndown)), dim=1)
-
-        bdown = torch.cat((0.5 * torch.ones(self.ndown, self.nup), 0.25 *
-                           torch.ones(self.ndown, self.ndown)), dim=1)
+        bup = torch.cat(
+            (
+                0.25 * torch.ones(self.nup, self.nup),
+                0.5 * torch.ones(self.nup, self.ndown),
+            ),
+            dim=1,
+        )
+
+        bdown = torch.cat(
+            (
+                0.5 * torch.ones(self.ndown, self.nup),
+                0.25 * torch.ones(self.ndown, self.ndown),
+            ),
+            dim=1,
+        )
 
         static_weight = torch.cat((bup, bdown), dim=0).to(self.device)
 
-        mask_tri_up = torch.triu(torch.ones_like(
-            static_weight), diagonal=1).type(torch.BoolTensor).to(self.device)
+        mask_tri_up = (
+            torch.triu(torch.ones_like(static_weight), diagonal=1)
+            .type(torch.BoolTensor)
+            .to(self.device)
+        )
         static_weight = static_weight.masked_select(mask_tri_up)
 
         return static_weight
 
-    def set_variational_weights(self, weight_a, weight_b):
+    def set_variational_weights(self, weight_a: Union[torch.Tensor, None], weight_b: Union[torch.Tensor, None]) -> None:
         """Define the initial values of the variational weights.
 
         Args:
@@ -75,7 +85,7 @@ def set_variational_weights(self, weight_a, weight_b):
         """
 
         # that can cause a nan if too low ...
-        w0 = 1E-5
+        w0 = 1e-5
 
         if weight_a is not None:
             assert weight_a.shape[0] == self.porder
@@ -88,13 +98,13 @@ def set_variational_weights(self, weight_a, weight_b):
             self.weight_b = nn.Parameter(weight_b)
         else:
             self.weight_b = nn.Parameter(w0 * torch.ones(self.porder))
-            self.weight_b.data[0] = 1.
+            self.weight_b.data[0] = 1.0
 
-        register_extra_attributes(self, ['weight_a'])
-        register_extra_attributes(self, ['weight_b'])
+        register_extra_attributes(self, ["weight_a"])
+        register_extra_attributes(self, ["weight_b"])
 
-    def forward(self, r):
-        """ Get the jastrow kernel.
+    def forward(self, r: torch.Tensor) -> torch.Tensor:
+        """Get the jastrow kernel.
 
         .. math::
 
@@ -113,7 +123,7 @@ def forward(self, r):
         num, denom = self._compute_polynoms(r)
         return num / denom
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels
         wrt to the first electrons
 
@@ -161,7 +171,7 @@ def compute_derivative(self, r, dr):
 
         return (der_num * denom - num * der_denom) / (denom * denom)
 
-    def compute_second_derivative(self, r, dr, d2r):
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Get the elements of the pure 2nd derivative of the jastrow kernels
         wrt to the first electron
 
@@ -191,16 +201,17 @@ def compute_second_derivative(self, r, dr, d2r):
 
         der_num, der_denom = self._compute_polynom_derivatives(r, dr)
 
-        d2_num, d2_denom = self._compute_polynom_second_derivative(
-            r, dr, d2r)
+        d2_num, d2_denom = self._compute_polynom_second_derivative(r, dr, d2r)
 
-        out = d2_num / denom - (2 * der_num * der_denom + num * d2_denom) / (
-            denom * denom) + 2 * num * der_denom * der_denom / (denom * denom *
-                                                                denom)
+        out = (
+            d2_num / denom
+            - (2 * der_num * der_denom + num * d2_denom) / (denom * denom)
+            + 2 * num * der_denom * der_denom / (denom * denom * denom)
+        )
 
         return out
 
-    def _compute_polynoms(self, r):
+    def _compute_polynoms(self, r: torch.Tensor) -> torch.Tensor:
         """Compute the num and denom polynomials.
 
         Args:
@@ -213,7 +224,7 @@ def _compute_polynoms(self, r):
         """
 
         num = self.static_weight * r
-        denom = (1.0 + self.weight_b[0] * r)
+        denom = 1.0 + self.weight_b[0] * r
         riord = r.clone()
 
         for iord in range(1, self.porder):
@@ -223,7 +234,7 @@ def _compute_polynoms(self, r):
 
         return num, denom
 
-    def _compute_polynom_derivatives(self, r, dr):
+    def _compute_polynom_derivatives(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Computes the derivatives of the polynomials.
 
         Args:
@@ -245,7 +256,6 @@ def _compute_polynom_derivatives(self, r, dr):
         riord = r.unsqueeze(1)
 
         for iord in range(1, self.porder):
-
             fact = (iord + 1) * dr * riord
             der_num += self.weight_a[iord] * fact
             der_denom += self.weight_b[iord] * fact
@@ -253,7 +263,7 @@ def _compute_polynom_derivatives(self, r, dr):
 
         return der_num, der_denom
 
-    def _compute_polynom_second_derivative(self, r, dr, d2r):
+    def _compute_polynom_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Computes the second derivative of the polynoms.
 
         Args:
@@ -277,10 +287,9 @@ def _compute_polynom_second_derivative(self, r, dr, d2r):
 
         r_ = r.unsqueeze(1)
         rnm1 = r.unsqueeze(1)
-        rnm2 = 1.
+        rnm2 = 1.0
 
         for iord in range(1, self.porder):
-
             n = iord + 1
             fact = n * (d2r * rnm1 + iord * dr2 * rnm2)
             d2_num += self.weight_a[iord] * fact
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py
index f51e9f5e..15d0dc21 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py
@@ -1,14 +1,13 @@
-
 import torch
 from torch import nn
 from torch.autograd import grad
-from .kernels.jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
+from .kernels.jastrow_kernel_electron_electron_base import (
+    JastrowKernelElectronElectronBase,
+)
 
 
 class OrbitalDependentJastrowKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self, nup, ndown, nmo, cuda,
-                 jastrow_kernel, kernel_kwargs={}):
+    def __init__(self, nup, ndown, nmo, cuda, jastrow_kernel, kernel_kwargs={}):
         """Transform a kernel into a orbital dependent kernel
 
         Args:
@@ -23,10 +22,11 @@ def __init__(self, nup, ndown, nmo, cuda,
         super().__init__(nup, ndown, cuda)
         self.nmo = nmo
         self.jastrow_functions = nn.ModuleList(
-            [jastrow_kernel(nup, ndown, cuda, **kernel_kwargs) for _ in range(self.nmo)])
+            [jastrow_kernel(nup, ndown, cuda, **kernel_kwargs) for _ in range(self.nmo)]
+        )
 
     def forward(self, r):
-        """ Get the jastrow kernel.
+        """Get the jastrow kernel.
 
         Args:
             r (torch.tensor): matrix of the e-e distances
@@ -66,9 +66,7 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             for jast in self.jastrow_functions:
-
                 kernel = jast(r)
                 ker_grad = self._grads(kernel, r)
                 ker_grad = ker_grad.unsqueeze(1) * dr
@@ -107,14 +105,11 @@ def compute_second_derivative(self, r, dr, d2r):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             for jast in self.jastrow_functions:
-
                 kernel = jast(r)
                 ker_hess, ker_grad = self._hess(kernel, r)
 
-                jhess = (ker_hess).unsqueeze(1) * \
-                    dr2 + ker_grad.unsqueeze(1) * d2r
+                jhess = (ker_hess).unsqueeze(1) * dr2 + ker_grad.unsqueeze(1) * d2r
 
                 jhess = jhess.unsqueeze(0)
 
@@ -155,11 +150,8 @@ def _hess(val, r):
             torch.tensor: second derivative of the values wrt to ee distance
         """
 
-        gval = grad(val, r,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        gval = grad(val, r, grad_outputs=torch.ones_like(val), create_graph=True)[0]
 
-        hval = grad(gval, r,
-                    grad_outputs=torch.ones_like(gval))[0]
+        hval = grad(gval, r, grad_outputs=torch.ones_like(gval))[0]
 
         return hval, gval
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index e69de29b..b3bf4d84 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -0,0 +1,7 @@
+from .jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei as JastrowFactor,
+)
+from .kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+
+__all__ = ["JastrowFactor", "BoysHandyJastrowKernel", "FullyConnectedJastrowKernel"]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/jastrow_factor_electron_electron_nuclei.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/jastrow_factor_electron_electron_nuclei.py
index 6bf688bf..27ca56ba 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/jastrow_factor_electron_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/jastrow_factor_electron_electron_nuclei.py
@@ -1,18 +1,19 @@
 import torch
 from torch import nn
-import torch
 from torch.autograd import Variable, grad
-
+from typing import Dict, Tuple, Optional, List, Union
 from ..distance.electron_electron_distance import ElectronElectronDistance
 from ..distance.electron_nuclei_distance import ElectronNucleiDistance
-
+from ....scf import Molecule
+from .kernels.jastrow_kernel_electron_electron_nuclei_base import JastrowKernelElectronElectronNucleiBase
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-
-    def __init__(self, nup, ndown, atomic_pos,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, 
+                 mol: Molecule, 
+                 jastrow_kernel: JastrowKernelElectronElectronNucleiBase, 
+                 kernel_kwargs: Dict = {}, 
+                 cuda: bool = False
+                 ) -> None:
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -21,43 +22,43 @@ def __init__(self, nup, ndown, atomic_pos,
         Args:
             nup (int): number of spin up electons
             ndow (int): number of spin down electons
+            atomic_pos(torch.tensor): positions of the atoms
+            jastrow_kernel (kernel): class of a electron-electron Jastrow kernel
+            kernel_kwargs (dict, optional): keyword argument of the kernel. Defaults to {}.
             cuda (bool, optional): Turns GPU ON/OFF. Defaults to False.
         """
 
         super().__init__()
 
-        self.nup = nup
-        self.ndown = ndown
-        self.nelec = nup + ndown
+        self.nup = mol.nup
+        self.ndown = mol.ndown
+        self.nelec = mol.nup + mol.ndown
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
+        atomic_pos = torch.as_tensor(mol.atom_coords)
         self.atoms = atomic_pos.to(self.device)
-        self.natoms = atomic_pos.shape[0]
+        self.natoms = self.atoms.shape[0]
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(nup, ndown,
-                                             atomic_pos,
-                                             cuda,
-                                             **kernel_kwargs)
+        self.jastrow_kernel = jastrow_kernel(
+            mol.nup, mol.ndown, atomic_pos, cuda, **kernel_kwargs
+        )
 
         # requires autograd to compute derivatives
         self.requires_autograd = self.jastrow_kernel.requires_autograd
 
         # index to extract tri up matrices
         self.mask_tri_up, self.index_col, self.index_row = self.get_mask_tri_up()
-        self.index_elec = [
-            self.index_row.tolist(), self.index_col.tolist()]
+        self.index_elec = [self.index_row.tolist(), self.index_col.tolist()]
 
         # distance calculator
-        self.elel_dist = ElectronElectronDistance(
-            self.nelec, self.ndim)
-        self.elnu_dist = ElectronNucleiDistance(
-            self.nelec, self.atoms, self.ndim)
+        self.elel_dist = ElectronElectronDistance(self.nelec, self.ndim)
+        self.elnu_dist = ElectronNucleiDistance(self.nelec, self.atoms, self.ndim)
 
         # method to compute the second derivative
         # If False jastrow_factor_second_derivative will be used
@@ -67,17 +68,16 @@ def __init__(self, nup, ndown, atomic_pos,
         # auto_second_derivative must be set to True.
         self.auto_second_derivative = True
 
-    def get_mask_tri_up(self):
+    def get_mask_tri_up(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         r"""Get the mask to select the triangular up matrix
 
         Returns:
             torch.tensor: mask of the tri up matrix
         """
-        mask = torch.zeros(self.nelec, self.nelec).type(
-            torch.bool).to(self.device)
+        mask = torch.zeros(self.nelec, self.nelec).type(torch.bool).to(self.device)
         index_col, index_row = [], []
-        for i in range(self.nelec-1):
-            for j in range(i+1, self.nelec):
+        for i in range(self.nelec - 1):
+            for j in range(i + 1, self.nelec):
                 index_row.append(i)
                 index_col.append(j)
                 mask[i, j] = True
@@ -86,7 +86,7 @@ def get_mask_tri_up(self):
         index_row = torch.LongTensor(index_row).to(self.device)
         return mask, index_col, index_row
 
-    def extract_tri_up(self, inp):
+    def extract_tri_up(self, inp: torch.Tensor) -> torch.Tensor:
         r"""extract the upper triangular elements
 
         Args:
@@ -99,7 +99,7 @@ def extract_tri_up(self, inp):
         out = inp.masked_select(self.mask_tri_up)
         return out.view(*(shape[:-2] + [-1]))
 
-    def extract_elec_nuc_dist(self, en_dist):
+    def extract_elec_nuc_dist(self, en_dist: torch.Tensor) -> torch.Tensor:
         r"""Organize the elec nuc distances
 
         Args:
@@ -117,10 +117,9 @@ def extract_elec_nuc_dist(self, en_dist):
         elif en_dist.ndim == 4:
             return out.permute(0, 1, 4, 3, 2)
         else:
-            raise ValueError(
-                'elec-nuc distance matrix should have 3 or 4 dim')
+            raise ValueError("elec-nuc distance matrix should have 3 or 4 dim")
 
-    def assemble_dist(self, pos):
+    def assemble_dist(self, pos: torch.Tensor) -> torch.Tensor:
         """Assemle the different distances for easy calculations
 
         Args:
@@ -143,7 +142,7 @@ def assemble_dist(self, pos):
         # cat both
         return torch.cat((ren, ree), -1)
 
-    def assemble_dist_deriv(self, pos, derivative=1):
+    def assemble_dist_deriv(self, pos: torch.Tensor, derivative: int = 1) -> torch.Tensor:
         """Assemle the different distances for easy calculations
            the output has dimension  nbatch, 3 x natom, nelec_pair, 3
            the last dimension is composed of [r_{e_1n}, r_{e_2n}, r_{ee}]
@@ -170,17 +169,17 @@ def assemble_dist_deriv(self, pos, derivative=1):
         # assemble
         return torch.cat((dren, dree), -1)
 
-    def _to_device(self):
+    def _to_device(self) -> None:
         """Export the non parameter variable to the device."""
 
-        self.device = torch.device('cuda')
+        self.device = torch.device("cuda")
         self.to(self.device)
-        attrs = ['static_weight']
+        attrs = ["static_weight"]
         for at in attrs:
             if at in self.__dict__:
                 self.__dict__[at] = self.__dict__[at].to(self.device)
 
-    def forward(self, pos, derivative=0, sum_grad=True):
+    def forward(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Compute the Jastrow factors.
 
         Args:
@@ -217,9 +216,10 @@ def forward(self, pos, derivative=0, sum_grad=True):
             return self.jastrow_factor_derivative(r, dr, jast, sum_grad)
 
         elif derivative == 2:
-
             if self.auto_second_derivative:
-                return self.jastrow_factor_second_derivative_auto(pos, jast=jast.unsqueeze(-1))
+                return self.jastrow_factor_second_derivative_auto(
+                    pos, jast=jast.unsqueeze(-1)
+                )
 
             else:
                 dr = self.assemble_dist_deriv(pos, 1)
@@ -228,25 +228,23 @@ def forward(self, pos, derivative=0, sum_grad=True):
                 return self.jastrow_factor_second_derivative(r, dr, d2r, jast)
 
         elif derivative == [0, 1, 2]:
-
             dr = self.assemble_dist_deriv(pos, 1)
-            djast = self.jastrow_factor_derivative(
-                r, dr, jast, sum_grad)
+            djast = self.jastrow_factor_derivative(r, dr, jast, sum_grad)
 
             if self.auto_second_derivative:
                 d2jast = self.jastrow_factor_second_derivative_auto(
-                    pos, jast=jast.unsqueeze(-1))
+                    pos, jast=jast.unsqueeze(-1)
+                )
             else:
                 d2r = self.assemble_dist_deriv(pos, 2)
-                d2jast = self.jastrow_factor_second_derivative(
-                    r, dr, d2r, jast)
+                d2jast = self.jastrow_factor_second_derivative(r, dr, d2r, jast)
 
-            return(jast.unsqueeze(-1), djast, d2jast)
+            return (jast.unsqueeze(-1), djast, d2jast)
 
         else:
-            raise ValueError('Derivative value nor recognized')
+            raise ValueError("Derivative value nor recognized")
 
-    def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
+    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
         """Compute the value of the derivative of the Jastrow factor
 
         Args:
@@ -260,7 +258,6 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
         """
 
         if sum_grad:
-
             # derivative of the jastrow elements
             # nbatch x ndim x natom x nelec_pair x 3
             # last dim is (ria rja rij)
@@ -285,7 +282,6 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
             out.index_add_(-1, self.index_col, djast[..., 1])
 
         else:
-
             # derivative of the jastrow elements
             # nbatch x ndim x natom x nelec_pair x 3
             # last dim is (ria rja rij)
@@ -293,8 +289,7 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
 
             # sum atom
             djast = djast.sum(2)
-            djast = djast * \
-                jast.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
+            djast = djast * jast.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
 
             # might cause problems with backward cause in place operation
             out_shape = list(djast.shape[:-2]) + [self.nelec]
@@ -310,7 +305,12 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
 
         return out
 
-    def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
+    def jastrow_factor_second_derivative(self, 
+                                         r: torch.Tensor, 
+                                         dr: torch.Tensor, 
+                                         d2r: torch.Tensor, 
+                                         jast: torch.Tensor
+                                         ) -> torch.Tensor:
         """Compute the value of the pure 2nd derivative of the Jastrow factor
 
         Args:
@@ -326,8 +326,7 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
         # puresecond derivative of the jast el
         # nbatch x ndim x natom x nelec_pair x 3
         # last dim is (ria rja rij)
-        d2jast = self.jastrow_kernel.compute_second_derivative(
-            r, dr, d2r)
+        d2jast = self.jastrow_kernel.compute_second_derivative(r, dr, d2r)
 
         # sum over the dim and the atom
         d2jast = d2jast.sum([1, 2])
@@ -352,7 +351,7 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
 
         return hess_jast * jast.unsqueeze(-1)
 
-    def partial_derivative(self, djast):
+    def partial_derivative(self, djast: torch.Tensor) -> torch.Tensor:
         """[summary]
 
         Args:
@@ -371,9 +370,12 @@ def partial_derivative(self, djast):
         out.index_add_(-1, self.index_row, djast[..., 0])
         out.index_add_(-1, self.index_col, djast[..., 1])
 
-        return ((out.sum(2))**2).sum(1)
+        return ((out.sum(2)) ** 2).sum(1)
 
-    def jastrow_factor_second_derivative_auto(self, pos, jast=None):
+    def jastrow_factor_second_derivative_auto(self, 
+                                              pos: torch.Tensor, 
+                                              jast: Union[None, torch.Tensor] = None
+                                              ) -> torch.Tensor:
         """Compute the second derivative of the jastrow factor automatically.
         This is needed for complicate kernels where the partial derivatives of
         the kernels are difficult to organize in a total derivaitve e.e Boys-Handy
@@ -383,24 +385,24 @@ def jastrow_factor_second_derivative_auto(self, pos, jast=None):
         """
 
         def hess(out, pos):
-
             # compute the jacobian
             z = Variable(torch.ones_like(out))
-            jacob = grad(out, pos,
-                         grad_outputs=z,
-                         only_inputs=True,
-                         create_graph=True)[0]
+            jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[
+                0
+            ]
 
             # compute the diagonal element of the Hessian
             z = Variable(torch.ones(jacob.shape[0])).to(self.device)
             hess = torch.zeros_like(jacob)
 
             for idim in range(jacob.shape[1]):
-
-                tmp = grad(jacob[:, idim], pos,
-                           grad_outputs=z,
-                           only_inputs=True,
-                           create_graph=True)[0]
+                tmp = grad(
+                    jacob[:, idim],
+                    pos,
+                    grad_outputs=z,
+                    only_inputs=True,
+                    create_graph=True,
+                )[0]
 
                 hess[:, idim] = tmp[:, idim]
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
index ed68119e..fd172437 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -1,3 +1,11 @@
 from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
-from .jastrow_kernel_electron_electron_nuclei_base import JastrowKernelElectronElectronNucleiBase
+from .jastrow_kernel_electron_electron_nuclei_base import (
+    JastrowKernelElectronElectronNucleiBase,
+)
 from .boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+
+__all__ = [
+    "FullyConnectedJastrowKernel",
+    "JastrowKernelElectronElectronNucleiBase",
+    "BoysHandyJastrowKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/boys_handy_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/boys_handy_jastrow_kernel.py
index caa8b797..a7bb1c25 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/boys_handy_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/boys_handy_jastrow_kernel.py
@@ -1,12 +1,20 @@
 import torch
 from torch import nn
-from .jastrow_kernel_electron_electron_nuclei_base import JastrowKernelElectronElectronNucleiBase
+from .jastrow_kernel_electron_electron_nuclei_base import (
+    JastrowKernelElectronElectronNucleiBase,
+)
 
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, nterm=5):
-        """Defines a Boys Handy jastrow factors.
+    def __init__(
+        self,
+        nup: int,
+        ndown: int,
+        atomic_pos: torch.Tensor,
+        cuda: bool,
+        nterm: int = 5
+        ) -> None:  # pylint: disable=too-many-arguments
+        r"""Defines a Boys Handy jastrow factors.
 
         J.W. Moskowitz et. al
         Correlated Monte Carlo Wave Functions for Some Cations and Anions of the First Row Atoms
@@ -32,7 +40,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, nterm=5):
         self.exp = nn.Parameter(torch.ones(2, self.nterm))
         self.repeat_dim = torch.as_tensor([2, 1]).to(self.device)
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the values of the kernel
 
         Args:
@@ -60,15 +68,13 @@ def forward(self, x):
         # x[1] = (a r_{jA})/(1 + b r_{jA})
         # x[2] = (a r_{ij})/(1 + b r_{ij})
         # output shape : [N, 3, nterm]
-        wnum = self.weight_num.repeat_interleave(
-            self.repeat_dim, dim=1)
-        wdenom = self.weight_denom.repeat_interleave(
-            self.repeat_dim, dim=1)
-        x = (wnum * x) / (1. + wdenom * x)
+        wnum = self.weight_num.repeat_interleave(self.repeat_dim, dim=1)
+        wdenom = self.weight_denom.repeat_interleave(self.repeat_dim, dim=1)
+        x = (wnum * x) / (1.0 + wdenom * x)
 
         # comput the powers
         xp = self.exp.repeat_interleave(self.repeat_dim, dim=0)
-        x = x**(xp)
+        x = x ** (xp)
 
         # product over the r_{iA}, r_{jA}, r_{ij}
         # output shape : [N, nterm]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/fully_connected_jastrow_kernel.py
index adb44a07..bb4c52b9 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/fully_connected_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/fully_connected_jastrow_kernel.py
@@ -1,12 +1,19 @@
 import torch
-from .jastrow_kernel_electron_electron_nuclei_base import JastrowKernelElectronElectronNucleiBase
+from .jastrow_kernel_electron_electron_nuclei_base import (
+    JastrowKernelElectronElectronNucleiBase,
+)
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronNucleiBase):
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool)-> None:
+        """Defines a fully connected jastrow factors.
 
-    def __init__(self, nup, ndown, atomic_pos, cuda):
-        """Defines a fully connected jastrow factors."""
-
+        Args:
+            nup (int): number of spin up electrons
+            ndown (int): number of spin down electrons
+            atomic_pos (torch.tensor): atomic positions of the atoms
+            cuda (bool): whether to use the GPU or not
+        """
         super().__init__(nup, ndown, atomic_pos, cuda)
 
         self.fc1 = torch.nn.Linear(3, 9, bias=True)
@@ -17,13 +24,13 @@ def __init__(self, nup, ndown, atomic_pos, cuda):
         torch.nn.init.uniform_(self.fc2.weight)
         torch.nn.init.uniform_(self.fc2.weight)
 
-        self.fc1.weight.data *= 1E-3
-        self.fc2.weight.data *= 1E-3
-        self.fc3.weight.data *= 1E-3
+        self.fc1.weight.data *= 1e-3
+        self.fc2.weight.data *= 1e-3
+        self.fc3.weight.data *= 1e-3
 
         self.nl_func = torch.nn.Sigmoid()
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the values of the individual f_ij=f(r_ij)
 
         Args:
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/jastrow_kernel_electron_electron_nuclei_base.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/jastrow_kernel_electron_electron_nuclei_base.py
index 9fc3416b..3de257e5 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/jastrow_kernel_electron_electron_nuclei_base.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/jastrow_kernel_electron_electron_nuclei_base.py
@@ -5,18 +5,15 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs) -> None:
         r"""Base Class for the elec-elec-nuc jastrow kernel
 
-
         Args:
             nup (int): number of spin up electons
-            ndow (int): number of spin down electons
-            atoms (torch.tensor): atomic positions of the atoms
+            ndown (int): number of spin down electons
+            atomic_pos (torch.tensor): atomic positions of the atoms
             cuda (bool, optional): Turns GPU ON/OFF. Defaults to False.
         """
-
         super().__init__()
         self.nup, self.ndown = nup, ndown
         self.cuda = cuda
@@ -26,12 +23,12 @@ def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         self.natoms = atomic_pos.shape[0]
         self.ndim = 3
 
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         self.requires_autograd = True
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the values of the kernel
 
         Args:
@@ -45,7 +42,7 @@ def forward(self, x):
         """
         raise NotImplementedError()
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels."""
 
         kernel = self.forward(r)
@@ -57,22 +54,20 @@ def compute_derivative(self, r, dr):
         # sum over the atoms
         return out
 
-    def compute_second_derivative(self, r, dr, d2r):
-        """Get the elements of the pure 2nd derivative of the jastrow kernels.
-        """
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+        """Get the elements of the pure 2nd derivative of the jastrow kernels."""
 
         dr2 = dr * dr
 
         kernel = self.forward(r)
         ker_hess, ker_grad = self._hess(kernel, r, self.device)
 
-        jhess = ker_hess.unsqueeze(1) * \
-            dr2 + ker_grad.unsqueeze(1) * d2r
+        jhess = ker_hess.unsqueeze(1) * dr2 + ker_grad.unsqueeze(1) * d2r
 
         return jhess
 
     @staticmethod
-    def _grads(val, pos):
+    def _grads(val, pos: torch.Tensor) -> torch.Tensor:
         """Get the gradients of the jastrow values
         of a given orbital terms
 
@@ -85,27 +80,26 @@ def _grads(val, pos):
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(val, pos, device):
+    def _hess(val, pos: torch.Tensor, device: torch.device) -> torch.Tensor:
         """get the hessian of the jastrow values.
 
         Args:
             pos ([type]): [description]
         """
 
-        gval = grad(val, pos,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        gval = grad(val, pos, grad_outputs=torch.ones_like(val), create_graph=True)[0]
 
-        grad_out = Variable(torch.ones(
-            *gval.shape[:-1])).to(device)
+        grad_out = Variable(torch.ones(*gval.shape[:-1])).to(device)
         hval = torch.zeros_like(gval).to(device)
 
         for idim in range(gval.shape[-1]):
-
-            tmp = grad(gval[..., idim], pos,
-                       grad_outputs=grad_out,
-                       only_inputs=True,
-                       create_graph=True)[0]
+            tmp = grad(
+                gval[..., idim],
+                pos,
+                grad_outputs=grad_out,
+                only_inputs=True,
+                create_graph=True,
+            )[0]
             hval[..., idim] = tmp[..., idim]
 
         return hval, gval
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index e69de29b..386aea4b 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -0,0 +1,5 @@
+from .jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei as JastrowFactor
+from .kernels.pade_jastrow_kernel import PadeJastrowKernel
+from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+
+__all__ = ["JastrowFactor", "PadeJastrowKernel", "FullyConnectedJastrowKernel"]
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
index 30bad26b..621603b7 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -1,14 +1,17 @@
 import torch
 from torch import nn
+from typing import Dict, Union, Tuple
 from ..distance.electron_nuclei_distance import ElectronNucleiDistance
-
+from ....scf import Molecule
+from .kernels.jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
 
 class JastrowFactorElectronNuclei(nn.Module):
-
-    def __init__(self, nup, ndown, atomic_pos,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, 
+                 mol: Molecule, 
+                 jastrow_kernel: JastrowKernelElectronNucleiBase, 
+                 kernel_kwargs: Dict = {}, 
+                 cuda: bool = False
+                 ) -> None:
         r"""Base class for two el-nuc jastrow of the form:
 
         .. math::
@@ -23,32 +26,40 @@ def __init__(self, nup, ndown, atomic_pos,
 
         super().__init__()
 
-        self.nup = nup
-        self.ndown = ndown
-        self.nelec = nup + ndown
+        self.nup = mol.nup
+        self.ndown = mol.ndown
+        self.nelec = mol.nup + mol.ndown
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
+        atomic_pos = torch.as_tensor(mol.atom_coords)
         self.atoms = atomic_pos.to(self.device)
-        self.natoms = atomic_pos.shape[0]
+        self.natoms = self.atoms.shape[0]
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(nup, ndown,
-                                             atomic_pos, cuda,
-                                             **kernel_kwargs)
+        self.jastrow_kernel = jastrow_kernel(
+            mol.nup, mol.ndown, atomic_pos, cuda, **kernel_kwargs
+        )
 
         # requires autograd to compute derivatives
         self.requires_autograd = self.jastrow_kernel.requires_autograd
 
         # elec-nuc distances
-        self.edist = ElectronNucleiDistance(
-            self.nelec, self.atoms, self.ndim)
+        self.edist = ElectronNucleiDistance(self.nelec, self.atoms, self.ndim)
 
-    def forward(self, pos, derivative=0, sum_grad=True):
+    def __repr__(self) -> str:
+        """representation of the jastrow factor"""
+        return "en -> " + self.jastrow_kernel.__class__.__name__
+
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: Union[int, Tuple[int]] = 0 , 
+                sum_grad: bool = True
+                ) -> Union[torch.Tensor, Tuple[torch.Tensor]]:
         """Compute the Jastrow factors.
 
         Args:
@@ -84,23 +95,22 @@ def forward(self, pos, derivative=0, sum_grad=True):
             return self.jastrow_factor_derivative(r, dr, jast, sum_grad)
 
         elif derivative == 2:
-
             dr = self.edist(pos, derivative=1)
             d2r = self.edist(pos, derivative=2)
 
             return self.jastrow_factor_second_derivative(r, dr, d2r, jast)
 
         elif derivative == [0, 1, 2]:
-
             dr = self.edist(pos, derivative=1)
             d2r = self.edist(pos, derivative=2)
 
-            return(jast,
-                   self.jastrow_factor_derivative(
-                       r, dr, jast, sum_grad),
-                   self.jastrow_factor_second_derivative(r, dr, d2r, jast))
+            return (
+                jast,
+                self.jastrow_factor_derivative(r, dr, jast, sum_grad),
+                self.jastrow_factor_second_derivative(r, dr, d2r, jast),
+            )
 
-    def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
+    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
         """Compute the value of the derivative of the Jastrow factor
 
         Args:
@@ -112,19 +122,19 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
             torch.tensor: gradient of the jastrow factors
                           Nbatch x Ndim x Nelec
         """
-        nbatch = r.shape[0]
         if sum_grad:
-
-            djast = self.jastrow_kernel.compute_derivative(
-                r, dr).sum((1, 3))
+            djast = self.jastrow_kernel.compute_derivative(r, dr).sum((1, 3))
             return djast * jast
         else:
-
-            djast = self.jastrow_kernel.compute_derivative(
-                r, dr).sum(3)
+            djast = self.jastrow_kernel.compute_derivative(r, dr).sum(3)
             return djast * jast.unsqueeze(-1)
 
-    def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
+    def jastrow_factor_second_derivative(self, 
+                                         r: torch.Tensor, 
+                                         dr: torch.Tensor, 
+                                         d2r: torch.Tensor, 
+                                         jast: torch.Tensor
+                                         ) -> torch.Tensor:
         """Compute the value of the pure 2nd derivative of the Jastrow factor
 
         Args:
@@ -136,15 +146,12 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
             torch.tensor: diagonal hessian of the jastrow factors
                           Nbatch x Nelec x Ndim
         """
-        nbatch = r.shape[0]
-
         # pure second derivative terms
-        d2jast = self.jastrow_kernel.compute_second_derivative(
-            r, dr, d2r).sum((1, 3))
+        d2jast = self.jastrow_kernel.compute_second_derivative(r, dr, d2r).sum((1, 3))
 
         # mixed terms
         djast = self.jastrow_kernel.compute_derivative(r, dr)
-        djast = ((djast.sum(3))**2).sum(1)
+        djast = ((djast.sum(3)) ** 2).sum(1)
 
         # add partial derivative
         hess_jast = d2jast + djast
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
index 177e5efb..6a042357 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
@@ -1,3 +1,9 @@
 from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 from .jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
 from .pade_jastrow_kernel import PadeJastrowKernel
+
+__all__ = [
+    "FullyConnectedJastrowKernel",
+    "JastrowKernelElectronNucleiBase",
+    "PadeJastrowKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
index beefdc28..beb06166 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
@@ -5,33 +5,35 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
+    def __init__(
+        self,
+        nup: int,
+        ndown: int,
+        atomic_pos: torch.Tensor,
+        cuda: bool,
+        w: float = 1.0
+    ) -> None:
         r"""Computes the Simple Pade-Jastrow factor
 
-        .. math::
-            J = \prod_{i<j} \exp(B_{ij}) \quad \quad \\text{with} \quad \quad
-            B_{ij} = \\frac{w_0 r_{i,j}}{1 + w r_{i,j}}
-
         Args:
             nup (int): number of spin up electons
             ndow (int): number of spin down electons
-            atoms (torch.tensor): atomic positions of the atoms
+            atomic_pos (torch.tensor): atomic positions of the atoms
             w (float, optional): Value of the variational parameter. Defaults to 1..
             cuda (bool, optional): Turns GPU ON/OFF. Defaults to False.
         """
 
         super().__init__(nup, ndown, atomic_pos, cuda)
 
-        self.fc1 = nn.Linear(1, 16, bias=False)
-        self.fc2 = nn.Linear(16, 8, bias=False)
-        self.fc3 = nn.Linear(8, 1, bias=False)
+        self.fc1: nn.Linear = nn.Linear(1, 16, bias=False)
+        self.fc2: nn.Linear = nn.Linear(16, 8, bias=False)
+        self.fc3: nn.Linear = nn.Linear(8, 1, bias=False)
 
-        self.nl_func = torch.nn.Sigmoid()
-        self.requires_autograd = True
+        self.nl_func: torch.nn.Sigmoid = torch.nn.Sigmoid()
+        self.requires_autograd: bool = True
 
-    def forward(self, x):
-        """ Get the jastrow kernel.
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Get the jastrow kernel.
 
         Args:
             x (torch.tensor): matrix of the e-e distances
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/jastrow_kernel_electron_nuclei_base.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/jastrow_kernel_electron_nuclei_base.py
index 9d0050e0..ccd38f54 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/jastrow_kernel_electron_nuclei_base.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/jastrow_kernel_electron_nuclei_base.py
@@ -1,11 +1,10 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-
+from typing import Tuple
 
 class JastrowKernelElectronNucleiBase(nn.Module):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs) -> None:
         r"""Base class for the elec-nuc jastrow factor
 
         .. math::
@@ -27,12 +26,12 @@ def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         self.natoms = atomic_pos.shape[0]
         self.ndim = 3
 
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         self.requires_autograd = True
 
-    def forward(self, r):
+    def forward(self, r: torch.Tensor) -> torch.Tensor:
         r"""Get the elements of the jastrow matrix :
         .. math::
             out_{i,j} = \exp{ \frac{b r_{i,j}}{1+b'r_{i,j}} }
@@ -47,7 +46,7 @@ def forward(self, r):
         """
         raise NotImplementedError()
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels
         wrt to the first electrons
 
@@ -73,13 +72,12 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(self, r, dr, d2r):
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Get the elements of the pure 2nd derivative of the jastrow kernels
         wrt to the first electron
 
@@ -108,18 +106,16 @@ def compute_second_derivative(self, r, dr, d2r):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
 
             ker_hess, ker_grad = self._hess(kernel, r)
 
-            jhess = (ker_hess).unsqueeze(1) * \
-                dr2 + ker_grad.unsqueeze(1) * d2r
+            jhess = (ker_hess).unsqueeze(1) * dr2 + ker_grad.unsqueeze(1) * d2r
 
         return jhess
 
     @staticmethod
-    def _grads(val, pos):
+    def _grads(val: torch.Tensor, pos: torch.Tensor) -> torch.Tensor:
         """Get the gradients of the jastrow values
         of a given orbital terms
 
@@ -132,7 +128,7 @@ def _grads(val, pos):
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(val, pos):
+    def _hess(val: torch.Tensor, pos: torch.Tensor) -> Tuple[torch.Tensor,torch.Tensor]:
         """get the hessian of the jastrow values.
         of a given orbital terms
         Warning thos work only because the orbital term are dependent
@@ -142,10 +138,7 @@ def _hess(val, pos):
             pos ([type]): [description]
         """
 
-        gval = grad(val,
-                    pos,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        gval = grad(val, pos, grad_outputs=torch.ones_like(val), create_graph=True)[0]
 
         hval = grad(gval, pos, grad_outputs=torch.ones_like(gval))[0]
 
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
index 501b0ae5..b6ca883f 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
@@ -6,8 +6,7 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronNucleiBase):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w: float = 1.0) -> None:
         r"""Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -24,15 +23,16 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
 
         super().__init__(nup, ndown, atomic_pos, cuda)
 
-        self.weight = nn.Parameter(
-            torch.as_tensor([w]), requires_grad=True).to(self.device)
-        register_extra_attributes(self, ['weight'])
+        self.weight = nn.Parameter(torch.as_tensor([w]), requires_grad=True).to(
+            self.device
+        )
+        register_extra_attributes(self, ["weight"])
 
-        self.static_weight = torch.as_tensor([1.]).to(self.device)
+        self.static_weight = torch.as_tensor([1.0]).to(self.device)
         self.requires_autograd = True
 
-    def forward(self, r):
-        """ Get the jastrow kernel.
+    def forward(self, r:torch.Tensor) -> torch.Tensor:
+        """Get the jastrow kernel.
         .. math::
             B_{ij} = \frac{b r_{i,j}}{1+b'r_{i,j}}
 
@@ -46,7 +46,7 @@ def forward(self, r):
         """
         return self.static_weight * r / (1.0 + self.weight * r)
 
-    def compute_derivative(self, r, dr):
+    def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Get the elements of the derivative of the jastrow kernels
         wrt to the first electrons
 
@@ -70,13 +70,13 @@ def compute_derivative(self, r, dr):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1. / (1.0 + self.weight * r_)
+        denom = 1.0 / (1.0 + self.weight * r_)
         a = self.static_weight * dr * denom
-        b = - self.static_weight * self.weight * r_ * dr * denom**2
+        b = -self.static_weight * self.weight * r_ * dr * denom**2
 
-        return (a + b)
+        return a + b
 
-    def compute_second_derivative(self, r, dr, d2r):
+    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
         """Get the elements of the pure 2nd derivative of the jastrow kernels
         wrt to the first electron
 
@@ -100,13 +100,13 @@ def compute_second_derivative(self, r, dr, d2r):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1. / (1.0 + self.weight * r_)
+        denom = 1.0 / (1.0 + self.weight * r_)
         denom2 = denom**2
-        dr_square = dr*dr
+        dr_square = dr * dr
 
         a = self.static_weight * d2r * denom
         b = -2 * self.static_weight * self.weight * dr_square * denom2
-        c = - self.static_weight * self.weight * r_ * d2r * denom2
+        c = -self.static_weight * self.weight * r_ * d2r * denom2
         d = 2 * self.static_weight * self.weight**2 * r_ * dr_square * denom**3
 
         return a + b + c + d
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
new file mode 100644
index 00000000..5b9df08a
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -0,0 +1,3 @@
+from .mgcn_jastrow import MGCNJastrowFactor
+
+__all__ = ["MGCNJastrowFactor"]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
new file mode 100644
index 00000000..f7d1467f
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -0,0 +1,45 @@
+import dgl
+import torch
+
+
+def ElecElecGraph(nelec: int, nup: int) -> dgl.DGLGraph:
+    """Create the elec-elec graph
+
+    Args:
+        nelec (int): total number of electrons
+        nup (int): numpber of spin up electrons
+
+    Returns:
+        [dgl.DGLGraph]: DGL graph
+    """
+    edges = get_elec_elec_edges(nelec)
+    graph = dgl.graph(edges)
+    graph.ndata["node_types"] = get_elec_elec_ndata(nelec, nup)
+    return graph
+
+
+def get_elec_elec_edges(nelec: int) -> list:
+    """Compute the edge index of the electron-electron graph."""
+    ee_edges = ([], [])
+    for i in range(nelec - 1):
+        for j in range(i + 1, nelec):
+            ee_edges[0].append(i)
+            ee_edges[1].append(j)
+
+            ee_edges[0].append(j)
+            ee_edges[1].append(i)
+
+    return ee_edges
+
+
+def get_elec_elec_ndata(nelec:int , nup: int) -> torch.Tensor:
+    """Compute the node data of the elec-elec graph"""
+
+    ee_ndata = []
+    for i in range(nelec):
+        if i < nup:
+            ee_ndata.append(0)
+        else:
+            ee_ndata.append(1)
+
+    return torch.LongTensor(ee_ndata)
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
new file mode 100644
index 00000000..2d136a54
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -0,0 +1,83 @@
+import dgl
+import torch
+from mendeleev import element
+
+
+def ElecNucGraph(natoms:int, atom_types:list, atomic_features:list, nelec:int, nup:int) -> dgl.DGLGraph:
+    """Create the elec-nuc graph
+
+    Args:
+        nelec (int): total number of electrons
+        nup (int): numpber of spin up electrons
+
+    Returns:
+        [dgl.DGLGraph]: DGL graph
+    """
+    edges = get_elec_nuc_edges(natoms, nelec)
+    graph = dgl.graph(edges)
+    graph.ndata["node_types"] = get_elec_nuc_ndata(
+        natoms, atom_types, atomic_features, nelec, nup
+    )
+    return graph
+
+
+def get_elec_nuc_edges(natoms: int, nelec: int) -> tuple:
+    """Compute the edge index of the electron-nuclei graph."""
+    en_edges = ([], [])
+    for i in range(natoms):
+        for j in range(nelec):
+            en_edges[0].append(i)
+            en_edges[1].append(natoms + j)
+
+            en_edges[0].append(natoms + j)
+            en_edges[1].append(i)
+
+    # for i in range(natoms-1):
+    #     for j in range(i+1, natoms):
+    #         en_edges[0].append(i)
+    #         en_edges[1].append(j)
+    return en_edges
+
+
+def get_elec_nuc_ndata(natoms: int, atom_types: list, atomic_features: list, nelec: int, nup: int) -> torch.Tensor:
+    """Compute the node data of the elec-elec graph"""
+
+    en_ndata = []
+    embed_number = 0
+    atom_dict = {}
+
+    for i in range(natoms):
+        if atom_types[i] not in atom_dict:
+            atom_dict[atom_types[i]] = embed_number
+            en_ndata.append(embed_number)
+            embed_number += 1
+        else:
+            en_ndata.append(atom_dict[atom_types[i]])
+
+        # feat = get_atomic_features(atom_types[i], atomic_features)
+        # feat.append(0)  # spin
+        # en_ndata.append(feat)
+
+    for i in range(nelec):
+        # feat = get_atomic_features(None, atomic_features)
+        if i < nup:
+            en_ndata.append(embed_number)
+        else:
+            en_ndata.append(embed_number + 1)
+
+    return torch.LongTensor(en_ndata)
+
+
+def get_atomic_features(atom_type: list, atomic_features: list) -> list:
+    """Get the atomic features requested."""
+    if atom_type is not None:
+        data = element(atom_type)
+        feat = [getattr(data, feat) for feat in atomic_features]
+    else:
+        feat = []
+        for atf in atomic_features:
+            if atf == "atomic_number":
+                feat.append(-1)
+            else:
+                feat.append(0)
+    return feat
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
new file mode 100644
index 00000000..40a896b9
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -0,0 +1,272 @@
+import torch
+from torch import nn
+from torch.autograd import grad
+from typing import Dict, List, Union, Tuple
+import dgl
+
+from dgllife.model.model_zoo.mgcn_predictor import MGCNPredictor
+from ..distance.electron_electron_distance import ElectronElectronDistance
+from ..distance.electron_nuclei_distance import ElectronNucleiDistance
+from .elec_elec_graph import ElecElecGraph
+from .elec_nuc_graph import ElecNucGraph
+from ....scf import Molecule
+
+class MGCNJastrowFactor(nn.Module):
+    def __init__(
+        self,
+        mol: Molecule,
+        ee_model_kwargs: Dict = {},
+        en_model_kwargs: Dict = {},
+        atomic_features: List = ["atomic_number"],
+        cuda: bool = False,
+    ) -> None:
+        """Graph Neural Network Jastrow Factor
+
+        Args:
+            nup (int): number of spin up electons
+            ndow (int): number of spin down electons
+            atomic_pos(torch.tensor): positions of the atoms
+            atoms (list): atom type in the molecule
+            ee_network (dgl model): graph network of the elec-elec factor
+            ee_network_kwargs (dict, optional): Argument of the elec-elec graph network. Defaults to {}.
+            en_network (dgl model): graph network of the elec-nuc factor
+            en_network_kwargs (dict, optional): Argument of the elec-nuc graph network. Defaults to {}.
+            atomic_featires (list, optional): list of atomic properties from medeleev
+            cuda (bool, optional): use cuda. Defaults to False.
+        """
+
+        super().__init__()
+
+        self.nup = mol.nup
+        self.ndown = mol.ndown
+        self.nelec = mol.nup + mol.ndown
+        self.ndim = 3
+
+        self.cuda = cuda
+        self.device = torch.device("cpu")
+        if self.cuda:
+            self.device = torch.device("cuda")
+
+        self.atom_types = mol.atoms
+        self.atomic_features = atomic_features
+        self.atoms = torch.as_tensor(mol.atom_coords).to(self.device)
+        self.natoms = self.atoms.shape[0]
+
+        self.requires_autograd = True
+
+        # mask to extract the upper diag of the matrices
+        self.mask_tri_up, self.index_col, self.index_row = self.get_mask_tri_up()
+
+        # distance calculator
+        self.elel_dist = ElectronElectronDistance(self.nelec, self.ndim)
+        self.elnu_dist = ElectronNucleiDistance(self.nelec, self.atoms, self.ndim)
+
+        # instantiate the ee mode; to use
+        ee_model_kwargs["num_node_types"] = 2
+        ee_model_kwargs["num_edge_types"] = 3
+        self.ee_model = MGCNPredictor(**ee_model_kwargs)
+
+        # instantiate the en model
+        en_model_kwargs["num_node_types"] = 2 + self.natoms
+        en_model_kwargs["num_edge_types"] = 2 * self.natoms
+        self.en_model = MGCNPredictor(**en_model_kwargs)
+
+        # compute the elec-elec graph
+        self.ee_graph = ElecElecGraph(self.nelec, self.nup)
+
+        # compute the elec-nuc graph
+        self.en_graph = ElecNucGraph(
+            self.natoms, self.atom_types, self.atomic_features, self.nelec, self.nup
+        )
+
+    def __repr__(self) -> str:
+        """representation of the jastrow factor"""
+        return "ee, en graph -> " + self.__class__.__name__
+
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: int = 0, 
+                sum_grad: bool = True
+                ) -> Union[torch.Tensor, Tuple[torch.Tensor,torch.Tensor,torch.Tensor]]:
+        """Compute the Jastrow factors.
+
+        Args:
+            pos (torch.tensor): Positions of the electrons
+                                  Size : Nbatch, Nelec x Ndim
+            derivative (int, optional): order of the derivative (0,1,2,).
+                            Defaults to 0.
+            sum_grad (bool, optional): Return the sum_grad (i.e. the sum of
+                                       the derivatives) or the individual
+                                       terms. Defaults to True.
+                                       False only for derivative=1
+
+        Returns:
+            torch.tensor: value of the jastrow parameter for all confs
+                          derivative = 0  (Nmo) x Nbatch x 1
+                          derivative = 1  (Nmo) x Nbatch x Nelec (for sum_grad = True)
+                          derivative = 1  (Nmo) x Nbatch x Ndim x Nelec (for sum_grad = False)
+                          derivative = 2  (Nmo) x Nbatch x Nelec
+        """
+
+        size = pos.shape
+        assert size[1] == self.nelec * self.ndim
+        nbatch = size[0]
+
+        batch_ee_graph = dgl.batch([self.ee_graph] * nbatch)
+        batch_en_graph = dgl.batch([self.en_graph] * nbatch)
+
+        # get the elec-elec distance matrix
+        ree = self.extract_tri_up(self.elel_dist(pos)).reshape(-1, 1)
+
+        # get the elec-nuc distance matrix
+        ren = self.extract_elec_nuc_dist(self.elnu_dist(pos))
+
+        # put the data in the graph
+        batch_ee_graph.edata["distance"] = ree.repeat_interleave(2, dim=0)
+        batch_en_graph.edata["distance"] = ren.repeat_interleave(2, dim=0)
+
+        ee_node_types = batch_ee_graph.ndata.pop("node_types")
+        ee_edge_distance = batch_ee_graph.edata.pop("distance")
+        ee_kernel = self.ee_model(batch_ee_graph, ee_node_types, ee_edge_distance)
+
+        en_node_types = batch_en_graph.ndata.pop("node_types")
+        en_edge_distance = batch_en_graph.edata.pop("distance")
+        en_kernel = self.en_model(batch_en_graph, en_node_types, en_edge_distance)
+
+        if derivative == 0:
+            return torch.exp(ee_kernel + en_kernel)
+
+        elif derivative == 1:
+            return self._get_grad_vals(pos, ee_kernel, en_kernel, sum_grad)
+
+        elif derivative == 2:
+            return self._get_hess_vals(pos, ee_kernel, en_kernel, return_all=False)
+
+        elif derivative == [0, 1, 2]:
+            return self._get_hess_vals(
+                pos, ee_kernel, en_kernel, sum_grad=sum_grad, return_all=True
+            )
+
+    def _get_val(self, ee_kernel: torch.Tensor, en_kernel: torch.Tensor) -> torch.Tensor:
+        """Get the jastrow values.
+
+        Args:
+            ee_kernel ([type]): [description]
+            en_kernel ([type]): [description]
+        """
+        return torch.exp(ee_kernel + en_kernel)
+
+    def _get_grad_vals(self, pos: torch.Tensor, ee_kernel: torch.Tensor, en_kernel: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+        """Get the values of the gradients
+
+
+        Args:
+            pos ([type]): [description]
+            ee_kernel ([type]): [description]
+            en_kernel ([type]): [description]
+            sum_grad ([type]): [description]
+        """
+
+        nbatch = len(pos)
+        jval = torch.exp(ee_kernel + en_kernel)
+        grad_val = grad(
+            jval, pos, grad_outputs=torch.ones_like(jval), only_inputs=True
+        )[0]
+        grad_val = grad_val.reshape(nbatch, self.nelec, 3).transpose(1, 2)
+
+        if sum_grad:
+            grad_val = grad_val.sum(1)
+
+        return grad_val
+
+    def _get_hess_vals(
+        self, pos: torch.Tensor, ee_kernel: torch.Tensor, en_kernel: torch.Tensor, sum_grad: bool = False, return_all: bool = False
+    ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
+        """Get the hessian values
+
+        Args:
+            pos ([type]): [description]
+            ee_kernel ([type]): [description]
+            en_kernel ([type]): [description]
+            sum_grad ([type]): [description]
+            return_all (bool, )
+        """
+
+        nbatch = len(pos)
+
+        jval = torch.exp(ee_kernel + en_kernel)
+
+        grad_val = grad(
+            jval,
+            pos,
+            grad_outputs=torch.ones_like(jval),
+            only_inputs=True,
+            create_graph=True,
+        )[0]
+
+        ndim = grad_val.shape[1]
+        hval = torch.zeros(nbatch, ndim).to(self.device)
+        z = torch.ones(grad_val.shape[0]).to(self.device)
+        z.requires_grad = True
+
+        for idim in range(ndim):
+            tmp = grad(
+                grad_val[:, idim],
+                pos,
+                grad_outputs=z,
+                only_inputs=True,
+                retain_graph=True,
+            )[0]
+            hval[:, idim] = tmp[:, idim]
+
+        hval = hval.reshape(nbatch, self.nelec, 3).transpose(1, 2).sum(1)
+
+        if return_all:
+            grad_val = grad_val.detach().reshape(nbatch, self.nelec, 3).transpose(1, 2)
+
+            if sum_grad:
+                grad_val = grad_val.sum(1)
+
+            return (jval, grad_val, hval)
+
+        else:
+            return hval
+
+    def get_mask_tri_up(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        r"""Get the mask to select the triangular up matrix
+
+        Returns:
+            torch.tensor: mask of the tri up matrix
+        """
+        mask = torch.zeros(self.nelec, self.nelec).type(torch.bool).to(self.device)
+        index_col, index_row = [], []
+        for i in range(self.nelec - 1):
+            for j in range(i + 1, self.nelec):
+                index_row.append(i)
+                index_col.append(j)
+                mask[i, j] = True
+
+        index_col = torch.LongTensor(index_col).to(self.device)
+        index_row = torch.LongTensor(index_row).to(self.device)
+        return mask, index_col, index_row
+
+    def extract_tri_up(self, inp: torch.Tensor) -> torch.Tensor:
+        r"""extract the upper triangular elements
+
+        Args:
+            input (torch.tensor): input matrices (..., nelec, nelec)
+
+        Returns:
+            torch.tensor: triangular up element (..., nelec_pair)
+        """
+        shape = list(inp.shape)
+        out = inp.masked_select(self.mask_tri_up)
+        return out.view(*(shape[:-2] + [-1]))
+
+    def extract_elec_nuc_dist(self, ren: torch.Tensor) -> torch.Tensor:
+        """reorganizre the elec-nuc distance to load them in the graph
+
+        Args:
+            ren (torch.tensor): distance elec-nuc [nbatch, nelec, natom]
+        """
+        return ren.transpose(1, 2).reshape(-1, 1)
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index 3f93394f..a6b8329c 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,29 +1,33 @@
-
-import torch
 from torch import nn
 from functools import reduce
 
 from .elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from .elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
-from .elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
+from .elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
 
 
-from .elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecElec
-from .elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecNuc
+from .elec_elec.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel as PadeJastrowKernelElecElec,
+)
+from .elec_nuclei.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel as PadeJastrowKernelElecNuc,
+)
 
 
 class JastrowFactorCombinedTerms(nn.Module):
-
-    def __init__(self, nup, ndown, atomic_pos,
-                 jastrow_kernel={
-                     'ee': PadeJastrowKernelElecElec,
-                     'en': PadeJastrowKernelElecNuc,
-                     'een': None},
-                 jastrow_kernel_kwargs={
-                     'ee': {},
-                     'en': {},
-                     'een': {}},
-                 cuda=False):
+    def __init__(
+        self,
+        mol,
+        jastrow_kernel={
+            "ee": PadeJastrowKernelElecElec,
+            "en": PadeJastrowKernelElecNuc,
+            "een": None,
+        },
+        jastrow_kernel_kwargs={"ee": {}, "en": {}, "een": {}},
+        cuda=False,
+    ):
         """[summary]
 
         Args:
@@ -36,14 +40,14 @@ def __init__(self, nup, ndown, atomic_pos,
         """
 
         super().__init__()
-        self.nup = nup
-        self.ndown = ndown
+        self.nup = mol.nup
+        self.ndown = mol.ndown
         self.cuda = cuda
-
-        self.jastrow_terms = []
+        self.jastrow_kernel_dict = jastrow_kernel
+        self.jastrow_terms = nn.ModuleList()
 
         # sanitize the dict
-        for k in ['ee', 'en', 'een']:
+        for k in ["ee", "en", "een"]:
             if k not in jastrow_kernel.keys():
                 jastrow_kernel[k] = None
             if k not in jastrow_kernel_kwargs.keys():
@@ -51,29 +55,36 @@ def __init__(self, nup, ndown, atomic_pos,
 
         self.requires_autograd = True
 
-        if jastrow_kernel['ee'] is not None:
-
-            self.jastrow_terms.append(JastrowFactorElectronElectron(nup, ndown,
-                                                                    jastrow_kernel['ee'],
-                                                                    jastrow_kernel_kwargs['ee'],
-                                                                    cuda=cuda))
-
-        if jastrow_kernel['en'] is not None:
-
-            self.jastrow_terms.append(JastrowFactorElectronNuclei(nup, ndown,
-                                                                  atomic_pos,
-                                                                  jastrow_kernel['en'],
-                                                                  jastrow_kernel_kwargs['en'],
-                                                                  cuda=cuda))
+        if jastrow_kernel["ee"] is not None:
+            self.jastrow_terms.append(
+                JastrowFactorElectronElectron(
+                    mol, jastrow_kernel["ee"], jastrow_kernel_kwargs["ee"], cuda=cuda
+                )
+            )
+
+        if jastrow_kernel["en"] is not None:
+            self.jastrow_terms.append(
+                JastrowFactorElectronNuclei(
+                    mol, jastrow_kernel["en"], jastrow_kernel_kwargs["en"], cuda=cuda
+                )
+            )
+
+        if jastrow_kernel["een"] is not None:
+            self.jastrow_terms.append(
+                JastrowFactorElectronElectronNuclei(
+                    mol, jastrow_kernel["een"], jastrow_kernel_kwargs["een"], cuda=cuda
+                )
+            )
+        self.nterms = len(self.jastrow_terms)
 
-        if jastrow_kernel['een'] is not None:
+    def __repr__(self):
+        """representation of the jastrow factor"""
+        out = []
+        for k in ["ee", "en", "een"]:
+            if self.jastrow_kernel_dict[k] is not None:
+                out.append(k + " -> " + self.jastrow_kernel_dict[k].__name__)
 
-            self.jastrow_terms.append(JastrowFactorElectronElectronNuclei(nup, ndown,
-                                                                          atomic_pos,
-                                                                          jastrow_kernel['een'],
-                                                                          jastrow_kernel_kwargs['een'],
-                                                                          cuda=cuda))
-        self.nterms = len(self.jastrow_terms)
+        return " + ".join(out)
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -97,69 +108,67 @@ def forward(self, pos, derivative=0, sum_grad=True):
                   (for sum_grad = False)
         """
         if derivative == 0:
-
             jast_vals = [term(pos) for term in self.jastrow_terms]
             return self.get_combined_values(jast_vals)
 
         elif derivative == 1:
-
             if sum_grad:
                 jast_vals = [term(pos) for term in self.jastrow_terms]
             else:
-                jast_vals = [term(pos).unsqueeze(-1)
-                             for term in self.jastrow_terms]
-            djast_vals = [term(pos, derivative=1, sum_grad=sum_grad)
-                          for term in self.jastrow_terms]
+                jast_vals = [term(pos).unsqueeze(-1) for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=sum_grad)
+                for term in self.jastrow_terms
+            ]
 
             return self.get_derivative_combined_values(jast_vals, djast_vals)
 
         elif derivative == 2:
-
-            jast_vals = [term(pos)
-                         for term in self.jastrow_terms]
-            djast_vals = [term(pos, derivative=1, sum_grad=False)
-                          for term in self.jastrow_terms]
-            d2jast_vals = [term(pos, derivative=2)
-                           for term in self.jastrow_terms]
-            return self.get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals)
+            jast_vals = [term(pos) for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=False) for term in self.jastrow_terms
+            ]
+            d2jast_vals = [term(pos, derivative=2) for term in self.jastrow_terms]
+            return self.get_second_derivative_combined_values(
+                jast_vals, djast_vals, d2jast_vals
+            )
 
         elif derivative == [0, 1, 2]:
-
             jast_vals = [term(pos) for term in self.jastrow_terms]
-            djast_vals = [term(pos, derivative=1, sum_grad=False)
-                          for term in self.jastrow_terms]
-            d2jast_vals = [term(pos, derivative=2)
-                           for term in self.jastrow_terms]
+            djast_vals = [
+                term(pos, derivative=1, sum_grad=False) for term in self.jastrow_terms
+            ]
+            d2jast_vals = [term(pos, derivative=2) for term in self.jastrow_terms]
 
             # combine the jastrow terms
             out_jast = self.get_combined_values(jast_vals)
 
             # combine the second derivative
             out_d2jast = self.get_second_derivative_combined_values(
-                jast_vals, djast_vals, d2jast_vals)
+                jast_vals, djast_vals, d2jast_vals
+            )
 
             # unsqueeze the jast terms to be compatible with the
             # derivative
             jast_vals = [j.unsqueeze(-1) for j in jast_vals]
 
             # combine the derivative
-            out_djast = self.get_derivative_combined_values(
-                jast_vals, djast_vals)
+            out_djast = self.get_derivative_combined_values(jast_vals, djast_vals)
 
-            return(out_jast, out_djast, out_d2jast)
+            return (out_jast, out_djast, out_d2jast)
 
         else:
-            raise ValueError('derivative not understood')
+            raise ValueError("derivative not understood")
 
-    @ staticmethod
+    @staticmethod
     def get_combined_values(jast_vals):
         """Compute the product of all terms in jast_vals."""
         if len(jast_vals) == 1:
             return jast_vals[0]
         else:
-            return reduce(lambda x, y: x*y, jast_vals)
+            return reduce(lambda x, y: x * y, jast_vals)
 
-    @ staticmethod
+    @staticmethod
     def get_derivative_combined_values(jast_vals, djast_vals):
         """Compute the derivative of the product.
         .. math:
@@ -169,15 +178,15 @@ def get_derivative_combined_values(jast_vals, djast_vals):
         if len(djast_vals) == 1:
             return djast_vals[0]
         else:
-            out = 0.
+            out = 0.0
             nterms = len(jast_vals)
             for i in range(nterms):
                 tmp = jast_vals.copy()
                 tmp[i] = djast_vals[i]
-                out += reduce(lambda x, y: x*y, tmp)
+                out += reduce(lambda x, y: x * y, tmp)
             return out
 
-    @ staticmethod
+    @staticmethod
     def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
         """Compute the derivative of the product.
         .. math:
@@ -188,25 +197,22 @@ def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
         if len(d2jast_vals) == 1:
             return d2jast_vals[0]
         else:
-            out = 0.
+            out = 0.0
             nterms = len(jast_vals)
             for i in range(nterms):
-
                 # d2a * b * c
                 tmp = jast_vals.copy()
                 tmp[i] = d2jast_vals[i]
-                out = out + reduce(lambda x, y: x*y, tmp)
-
-            for i in range(nterms-1):
-                for j in range(i+1, nterms):
+                out = out + reduce(lambda x, y: x * y, tmp)
 
+            for i in range(nterms - 1):
+                for j in range(i + 1, nterms):
                     # da * db * c
                     tmp = jast_vals.copy()
                     tmp = [j.unsqueeze(-1) for j in tmp]
                     tmp[i] = djast_vals[i]
                     tmp[j] = djast_vals[j]
 
-                    out = out + \
-                        (2.*reduce(lambda x, y: x*y, tmp)).sum(1)
+                    out = out + (2.0 * reduce(lambda x, y: x * y, tmp)).sum(1)
 
             return out
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index c3383923..1b375c58 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -1,15 +1,18 @@
 import torch
 from torch import nn
-
+from typing import Optional, List, Tuple
 from .norm_orbital import atomic_orbital_norm
-from .radial_functions import (radial_gaussian, radial_gaussian_pure,
-                               radial_slater, radial_slater_pure)
+from .radial_functions import (
+    radial_gaussian,
+    radial_gaussian_pure,
+    radial_slater,
+    radial_slater_pure,
+)
 from .spherical_harmonics import Harmonics
-
+from ...scf import Molecule
 
 class AtomicOrbitals(nn.Module):
-
-    def __init__(self, mol, cuda=False):
+    def __init__(self, mol: Molecule, cuda: Optional[bool] = False) -> None:
         """Computes the value of atomic orbitals
 
         Args:
@@ -26,8 +29,9 @@ def __init__(self, mol, cuda=False):
         self.ndim = 3
 
         # make the atomic position optmizable
-        self.atom_coords = nn.Parameter(torch.as_tensor(
-            mol.basis.atom_coords_internal).type(dtype))
+        self.atom_coords = nn.Parameter(
+            torch.as_tensor(mol.basis.atom_coords_internal).type(dtype)
+        )
         self.atom_coords.requires_grad = True
         self.natoms = len(self.atom_coords)
         self.atomic_number = mol.atomic_number
@@ -35,85 +39,102 @@ def __init__(self, mol, cuda=False):
         # define the BAS positions.
         self.nshells = torch.as_tensor(mol.basis.nshells)
         self.nao_per_atom = torch.as_tensor(mol.basis.nao_per_atom)
-        self.bas_coords = self.atom_coords.repeat_interleave(
-            self.nshells, dim=0)
+        self.bas_coords = self.atom_coords.repeat_interleave(self.nshells, dim=0)
         self.nbas = len(self.bas_coords)
 
         # index for the contractions
         self.index_ctr = torch.as_tensor(mol.basis.index_ctr)
         self.nctr_per_ao = torch.as_tensor(mol.basis.nctr_per_ao)
-        self.contract = not len(torch.unique(
-            self.index_ctr)) == len(self.index_ctr)
+        self.contract = not len(torch.unique(self.index_ctr)) == len(self.index_ctr)
 
         # get the coeffs of the bas
-        self.bas_coeffs = torch.as_tensor(
-            mol.basis.bas_coeffs).type(dtype)
+        self.bas_coeffs = torch.as_tensor(mol.basis.bas_coeffs).type(dtype)
 
         # get the exponents of the bas
-        self.bas_exp = nn.Parameter(
-            torch.as_tensor(mol.basis.bas_exp).type(dtype))
+        self.bas_exp = nn.Parameter(torch.as_tensor(mol.basis.bas_exp).type(dtype))
         self.bas_exp.requires_grad = True
 
         # harmonics generator
         self.harmonics_type = mol.basis.harmonics_type
-        if mol.basis.harmonics_type == 'sph':
+        if mol.basis.harmonics_type == "sph":
             self.bas_n = torch.as_tensor(mol.basis.bas_n).type(dtype)
             self.harmonics = Harmonics(
                 mol.basis.harmonics_type,
                 bas_l=mol.basis.bas_l,
                 bas_m=mol.basis.bas_m,
-                cuda=cuda)
+                cuda=cuda,
+            )
 
-        elif mol.basis.harmonics_type == 'cart':
+        elif mol.basis.harmonics_type == "cart":
             self.bas_n = torch.as_tensor(mol.basis.bas_kr).type(dtype)
             self.harmonics = Harmonics(
                 mol.basis.harmonics_type,
                 bas_kx=mol.basis.bas_kx,
                 bas_ky=mol.basis.bas_ky,
                 bas_kz=mol.basis.bas_kz,
-                cuda=cuda)
+                cuda=cuda,
+            )
 
         # select the radial apart
-        radial_dict = {'sto': radial_slater,
-                       'gto': radial_gaussian,
-                       'sto_pure': radial_slater_pure,
-                       'gto_pure': radial_gaussian_pure}
+        radial_dict = {
+            "sto": radial_slater,
+            "gto": radial_gaussian,
+            "sto_pure": radial_slater_pure,
+            "gto_pure": radial_gaussian_pure,
+        }
         self.radial = radial_dict[mol.basis.radial_type]
         self.radial_type = mol.basis.radial_type
 
         # get the normalisation constants
-        if hasattr(mol.basis, 'bas_norm') and False:
-            self.norm_cst = torch.as_tensor(
-                mol.basis.bas_norm).type(dtype)
+        if hasattr(mol.basis, "bas_norm") and False:
+            self.norm_cst = torch.as_tensor(mol.basis.bas_norm).type(dtype)
         else:
             with torch.no_grad():
-                self.norm_cst = atomic_orbital_norm(
-                    mol.basis).type(dtype)
+                self.norm_cst = atomic_orbital_norm(mol.basis).type(dtype)
+
+        # register a backflow_trans for consistency
+        self.backflow_trans = None
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
             self._to_device()
 
-    def __repr__(self):
+    def __repr__(self) -> None:
         name = self.__class__.__name__
-        return name + '(%s, %s, %d -> (%d,%d) )' % (self.radial_type, self.harmonics_type,
-                                                    self.nelec*self.ndim, self.nelec,
-                                                    self.norb)
-
-    def _to_device(self):
+        return name + "(%s, %s, %d -> (%d,%d) )" % (
+            self.radial_type,
+            self.harmonics_type,
+            self.nelec * self.ndim,
+            self.nelec,
+            self.norb,
+        )
+
+    def _to_device(self) -> None:
         """Export the non parameter variable to the device."""
 
-        self.device = torch.device('cuda')
+        self.device = torch.device("cuda")
         self.to(self.device)
-        attrs = ['bas_n', 'bas_coeffs',
-                 'nshells', 'norm_cst',
-                 'index_ctr', 'nctr_per_ao',
-                 'nao_per_atom']
+        attrs = [
+            "bas_n",
+            "bas_coeffs",
+            "nshells",
+            "norm_cst",
+            "index_ctr",
+            "nctr_per_ao",
+            "nao_per_atom",
+        ]
         for at in attrs:
             self.__dict__[at] = self.__dict__[at].to(self.device)
 
-    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
+    def forward(
+        self, 
+        pos: torch.Tensor, 
+        derivative: Optional[List[int]] = [0], 
+        sum_grad: Optional[bool] = True, 
+        sum_hess: Optional[bool] = True, 
+        one_elec: Optional[bool] = False
+    ) -> torch.Tensor:
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -161,10 +182,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             derivative = [derivative]
 
         if not sum_grad:
-            assert(1 in derivative)
+            assert 1 in derivative
 
         if not sum_hess:
-            assert(2 in derivative)
+            assert 2 in derivative
 
         if one_elec:
             nelec_save = self.nelec
@@ -174,12 +195,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             ao = self._compute_ao_values(pos)
 
         elif derivative == [1]:
-            ao = self._compute_first_derivative_ao_values(
-                pos, sum_grad)
+            ao = self._compute_first_derivative_ao_values(pos, sum_grad)
 
         elif derivative == [2]:
-            ao = self._compute_second_derivative_ao_values(
-                pos, sum_hess)
+            ao = self._compute_second_derivative_ao_values(pos, sum_hess)
 
         elif derivative == [3]:
             ao = self._compute_mixed_second_derivative_ao_values(pos)
@@ -189,14 +208,15 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
 
         else:
             raise ValueError(
-                'derivative must be 0, 1, 2, 3 or [0, 1, 2, 3], got ', derivative)
+                "derivative must be 0, 1, 2, 3 or [0, 1, 2, 3], got ", derivative
+            )
 
         if one_elec:
             self.nelec = nelec_save
 
         return ao
 
-    def _compute_ao_values(self, pos):
+    def _compute_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the value of the ao from the xyx and r tensor
 
         Args:
@@ -212,7 +232,7 @@ def _compute_ao_values(self, pos):
         Y = self.harmonics(xyz)
         return self._ao_kernel(R, Y)
 
-    def _ao_kernel(self, R, Y):
+    def _ao_kernel(self, R: torch.Tensor, Y: torch.Tensor) -> torch.Tensor:
         """Kernel for the ao values
 
         Args:
@@ -227,7 +247,7 @@ def _ao_kernel(self, R, Y):
             ao = self._contract(ao)
         return ao
 
-    def _compute_first_derivative_ao_values(self, pos, sum_grad):
+    def _compute_first_derivative_ao_values(self, pos: torch.Tensor, sum_grad: bool) -> torch.Tensor:
         """Compute the value of the derivative of the ao from the xyx and r tensor
 
         Args:
@@ -244,7 +264,7 @@ def _compute_first_derivative_ao_values(self, pos, sum_grad):
         else:
             return self._compute_gradient_ao_values(pos)
 
-    def _compute_sum_gradient_ao_values(self, pos):
+    def _compute_sum_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the jacobian of the ao from the xyx and r tensor
 
         Args:
@@ -258,15 +278,18 @@ def _compute_sum_gradient_ao_values(self, pos):
 
         xyz, r = self._process_position(pos)
 
-        R, dR = self.radial(r, self.bas_n,
-                            self.bas_exp, xyz=xyz,
-                            derivative=[0, 1])
+        R, dR = self.radial(r, self.bas_n, self.bas_exp, xyz=xyz, derivative=[0, 1])
 
         Y, dY = self.harmonics(xyz, derivative=[0, 1])
 
         return self._sum_gradient_kernel(R, dR, Y, dY)
 
-    def _sum_gradient_kernel(self, R, dR, Y, dY):
+    def _sum_gradient_kernel(self, 
+                             R: torch.Tensor, 
+                             dR: torch.Tensor, 
+                             Y: torch.Tensor, 
+                             dY: torch.Tensor
+                             ) -> torch.Tensor :
         """Kernel for the jacobian of the ao values
 
         Args:
@@ -283,7 +306,7 @@ def _sum_gradient_kernel(self, R, dR, Y, dY):
             dao = self._contract(dao)
         return dao
 
-    def _compute_gradient_ao_values(self, pos):
+    def _compute_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the gradient of the ao from the xyx and r tensor
 
         Args:
@@ -296,16 +319,20 @@ def _compute_gradient_ao_values(self, pos):
         """
         xyz, r = self._process_position(pos)
 
-        R, dR = self.radial(r, self.bas_n,
-                            self.bas_exp, xyz=xyz,
-                            derivative=[0, 1],
-                            sum_grad=False)
+        R, dR = self.radial(
+            r, self.bas_n, self.bas_exp, xyz=xyz, derivative=[0, 1], sum_grad=False
+        )
 
         Y, dY = self.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         return self._gradient_kernel(R, dR, Y, dY)
 
-    def _gradient_kernel(self, R, dR, Y, dY):
+    def _gradient_kernel(self, 
+                         R: torch.Tensor, 
+                         dR: torch.Tensor, 
+                         Y: torch.Tensor, 
+                         dY: torch.Tensor
+                         ) -> torch.Tensor:
         """Kernel for the gradient of the ao values
 
         Args:
@@ -320,18 +347,18 @@ def _gradient_kernel(self, R, dR, Y, dY):
         nbatch = R.shape[0]
         bas = dR * Y.unsqueeze(-1) + R.unsqueeze(-1) * dY
 
-        bas = self.norm_cst.unsqueeze(-1) * \
-            self.bas_coeffs.unsqueeze(-1) * bas
+        bas = self.norm_cst.unsqueeze(-1) * self.bas_coeffs.unsqueeze(-1) * bas
 
         if self.contract:
-            ao = torch.zeros(nbatch, self.nelec, self.norb,
-                             3, device=self.device).type(torch.get_default_dtype())
+            ao = torch.zeros(nbatch, self.nelec, self.norb, 3, device=self.device).type(
+                torch.get_default_dtype()
+            )
             ao.index_add_(2, self.index_ctr, bas)
         else:
             ao = bas
         return ao
 
-    def _compute_second_derivative_ao_values(self, pos, sum_hess):
+    def _compute_second_derivative_ao_values(self, pos: torch.Tensor, sum_hess: bool) -> torch.Tensor:
         """Compute the values of the 2nd derivative of the ao from the xyz and r tensors
 
         Args:
@@ -348,7 +375,7 @@ def _compute_second_derivative_ao_values(self, pos, sum_hess):
         else:
             return self._compute_diag_hessian_ao_values(pos)
 
-    def _compute_sum_diag_hessian_ao_values(self, pos):
+    def _compute_sum_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the laplacian of the ao from the xyx and r tensor
 
         Args:
@@ -361,16 +388,21 @@ def _compute_sum_diag_hessian_ao_values(self, pos):
         """
         xyz, r = self._process_position(pos)
 
-        R, dR, d2R = self.radial(r, self.bas_n, self.bas_exp,
-                                 xyz=xyz, derivative=[0, 1, 2],
-                                 sum_grad=False)
+        R, dR, d2R = self.radial(
+            r, self.bas_n, self.bas_exp, xyz=xyz, derivative=[0, 1, 2], sum_grad=False
+        )
 
-        Y, dY, d2Y = self.harmonics(xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False)
+        Y, dY, d2Y = self.harmonics(xyz, derivative=[0, 1, 2], sum_grad=False)
         return self._sum_diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y)
 
-    def _sum_diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
+    def _sum_diag_hessian_kernel(self, 
+                                 R: torch.Tensor, 
+                                 dR: torch.Tensor, 
+                                 d2R: torch.Tensor, 
+                                 Y: torch.Tensor, 
+                                 dY: torch.Tensor, 
+                                 d2Y: torch.Tensor
+                                 ) -> torch.Tensor:
         """Kernel for the sum of the diag hessian of the ao values
 
         Args:
@@ -385,13 +417,12 @@ def _sum_diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
             torch.tensor: values of the laplacian of the AOs (with contraction)
         """
 
-        d2ao = self.norm_cst * \
-            (d2R * Y + 2. * (dR * dY).sum(3) + R * d2Y)
+        d2ao = self.norm_cst * (d2R * Y + 2.0 * (dR * dY).sum(3) + R * d2Y)
         if self.contract:
             d2ao = self._contract(d2ao)
         return d2ao
 
-    def _compute_diag_hessian_ao_values(self, pos):
+    def _compute_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the individual elements of the laplacian of the ao from the xyx and r tensor
 
         Args:
@@ -405,17 +436,30 @@ def _compute_diag_hessian_ao_values(self, pos):
 
         xyz, r = self._process_position(pos)
 
-        R, dR, d2R = self.radial(r, self.bas_n, self.bas_exp,
-                                 xyz=xyz, derivative=[0, 1, 2],
-                                 sum_grad=False, sum_hess=False)
+        R, dR, d2R = self.radial(
+            r,
+            self.bas_n,
+            self.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2],
+            sum_grad=False,
+            sum_hess=False,
+        )
 
-        Y, dY, d2Y = self.harmonics(xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False, sum_hess=False)
+        Y, dY, d2Y = self.harmonics(
+            xyz, derivative=[0, 1, 2], sum_grad=False, sum_hess=False
+        )
 
         return self._diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y)
 
-    def _diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
+    def _diag_hessian_kernel(self, 
+                             R: torch.Tensor, 
+                             dR: torch.Tensor, 
+                             d2R: torch.Tensor, 
+                             Y: torch.Tensor, 
+                             dY: torch.Tensor, 
+                             d2Y: torch.Tensor
+                             ) -> torch.Tensor:
         """Kernel for the diagonal hessian of the ao values
 
         Args:
@@ -432,20 +476,23 @@ def _diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
 
         nbatch = R.shape[0]
 
-        bas = self.norm_cst.unsqueeze(-1) * self.bas_coeffs.unsqueeze(-1) * \
-            (d2R * Y.unsqueeze(-1) + 2. *
-             (dR * dY) + R.unsqueeze(-1) * d2Y)
+        bas = (
+            self.norm_cst.unsqueeze(-1)
+            * self.bas_coeffs.unsqueeze(-1)
+            * (d2R * Y.unsqueeze(-1) + 2.0 * (dR * dY) + R.unsqueeze(-1) * d2Y)
+        )
 
         if self.contract:
-            d2ao = torch.zeros(nbatch, self.nelec, self.norb,
-                               3, device=self.device).type(torch.get_default_dtype())
+            d2ao = torch.zeros(
+                nbatch, self.nelec, self.norb, 3, device=self.device
+            ).type(torch.get_default_dtype())
             d2ao.index_add_(2, self.index_ctr, bas)
         else:
             d2ao = bas
 
         return d2ao
 
-    def _compute_mixed_second_derivative_ao_values(self, pos):
+    def _compute_mixed_second_derivative_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the mixed second derivative of the ao from the xyx and r tensor
 
         Args:
@@ -458,85 +505,107 @@ def _compute_mixed_second_derivative_ao_values(self, pos):
         """
         xyz, r = self._process_position(pos)
 
-        R, dR, d2R, d2mR = self.radial(r, self.bas_n, self.bas_exp,
-                                       xyz=xyz, derivative=[
-                                           0, 1, 2, 3],
-                                       sum_grad=False)
+        R, dR, d2R, d2mR = self.radial(
+            r,
+            self.bas_n,
+            self.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2, 3],
+            sum_grad=False,
+        )
 
-        Y, dY, d2Y, d2mY = self.harmonics(xyz,
-                                          derivative=[0, 1, 2, 3],
-                                          sum_grad=False)
+        Y, dY, d2Y, d2mY = self.harmonics(xyz, derivative=[0, 1, 2, 3], sum_grad=False)
 
         return self._off_diag_hessian_kernel(R, dR, d2R, d2mR, Y, dY, d2Y, d2mY)
 
-    def _off_diag_hessian_kernel(self, R, dR, d2R, d2mR, Y, dY, d2Y, d2mY):
+    def _off_diag_hessian_kernel(
+        self,
+        R: torch.Tensor,
+        dR: torch.Tensor,
+        d2R: torch.Tensor,
+        d2mR: torch.Tensor,
+        Y: torch.Tensor,
+        dY: torch.Tensor,
+        d2Y: torch.Tensor,
+        d2mY: torch.Tensor,
+    ) -> torch.Tensor:
         """Kernel for the off diagonal hessian of the ao values
 
         Args:
-            R (torch.tensor): radial part of the AOs
-            dR (torch.tensor): derivative of the radial part of the AOs
-            d2R (torch.tensor): 2nd derivative of the radial part of the AOs
-            d2mR (torch.tensor): mixed 2nd derivative of the radial part of the AOs
-            Y (torch.tensor): harmonics part of the AOs
-            dY (torch.tensor): derivative of the harmonics part of the AOs
-            d2Y (torch.tensor): 2nd derivative of the harmonics part of the AOs
-            d2mY (torch.tensor): 2nd mixed derivative of the harmonics part of the AOs
+            R (torch.Tensor): radial part of the AOs
+            dR (torch.Tensor): derivative of the radial part of the AOs
+            d2R (torch.Tensor): 2nd derivative of the radial part of the AOs
+            d2mR (torch.Tensor): mixed 2nd derivative of the radial part of the AOs
+            Y (torch.Tensor): harmonics part of the AOs
+            dY (torch.Tensor): derivative of the harmonics part of the AOs
+            d2Y (torch.Tensor): 2nd derivative of the harmonics part of the AOs
+            d2mY (torch.Tensor): 2nd mixed derivative of the harmonics part of the AOs
 
         Returns:
-            torch.tensor: values of the mixed derivative of the AOs (with contraction)
+            torch.Tensor: values of the mixed derivative of the AOs (with contraction)
         """
 
         nbatch = R.shape[0]
 
-        bas = self.norm_cst.unsqueeze(-1) * self.bas_coeffs.unsqueeze(-1) * \
-            (d2mR * Y.unsqueeze(-1) +
-             ((dR[..., [[0, 1], [0, 2], [1, 2]]] *
-               dY[..., [[1, 0], [2, 0], [2, 1]]]).sum(-1))
-             + R.unsqueeze(-1) * d2mY)
+        bas = (
+            self.norm_cst.unsqueeze(-1)
+            * self.bas_coeffs.unsqueeze(-1)
+            * (
+                d2mR * Y.unsqueeze(-1)
+                + (
+                    (
+                        dR[..., [[0, 1], [0, 2], [1, 2]]]
+                        * dY[..., [[1, 0], [2, 0], [2, 1]]]
+                    ).sum(-1)
+                )
+                + R.unsqueeze(-1) * d2mY
+            )
+        )
 
         if self.contract:
-            d2ao = torch.zeros(nbatch, self.nelec, self.norb,
-                               3, device=self.device).type(torch.get_default_dtype())
+            d2ao = torch.zeros(
+                nbatch, self.nelec, self.norb, 3, device=self.device
+            ).type(torch.get_default_dtype())
             d2ao.index_add_(2, self.index_ctr, bas)
         else:
             d2ao = bas
 
         return d2ao
 
-    def _compute_all_ao_values(self, pos):
+    def _compute_all_ao_values(
+        self, pos: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         """Compute the ao, gradient, laplacian of the ao from the xyx and r tensor
 
         Args:
             pos (torch.tensor): position of each elec size Nbatch, Nelec x Ndim
-            sum_grad (bool): return the sum of the gradients if True
-            sum_hess (bool): returns the sum of the diag hess if True
+
         Returns:
             tuple(): (ao, grad and lapalcian) of atomic orbital values
                      ao size (Nbatch, Nelec, Norb)
                      dao size (Nbatch, Nelec, Norb, Ndim)
                      d2ao size (Nbatch, Nelec, Norb)
-
         """
 
         xyz, r = self._process_position(pos)
 
         # the gradients elements are needed to compute the second der
         # we therefore use sum_grad=False regardless of the input arg
-        R, dR, d2R = self.radial(r, self.bas_n, self.bas_exp,
-                                 xyz=xyz, derivative=[0, 1, 2],
-                                 sum_grad=False)
+        R, dR, d2R = self.radial(
+            r, self.bas_n, self.bas_exp, xyz=xyz, derivative=[0, 1, 2], sum_grad=False
+        )
 
         # the gradients elements are needed to compute the second der
         # we therefore use sum_grad=False regardless of the input arg
-        Y, dY, d2Y = self.harmonics(xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False)
+        Y, dY, d2Y = self.harmonics(xyz, derivative=[0, 1, 2], sum_grad=False)
 
-        return (self._ao_kernel(R, Y),
-                self._gradient_kernel(R, dR, Y, dY),
-                self._sum_diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y))
+        return (
+            self._ao_kernel(R, Y),
+            self._gradient_kernel(R, dR, Y, dY),
+            self._sum_diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y),
+        )
 
-    def _process_position(self, pos):
+    def _process_position(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/orb
 
         Args:
@@ -553,10 +622,12 @@ def _process_position(self, pos):
 
         # repeat/interleave to get vector and distance between
         # electrons and orbitals
-        return (xyz.repeat_interleave(self.nshells, dim=2),
-                r.repeat_interleave(self.nshells, dim=2))
+        return (
+            xyz.repeat_interleave(self.nshells, dim=2),
+            r.repeat_interleave(self.nshells, dim=2),
+        )
 
-    def _elec_atom_dist(self, pos):
+    def _elec_atom_dist(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/atoms
 
         Args:
@@ -570,15 +641,14 @@ def _elec_atom_dist(self, pos):
         """
 
         # compute the vectors between electrons and atoms
-        xyz = (pos.view(-1, self.nelec, 1, self.ndim) -
-               self.atom_coords[None, ...])
+        xyz = pos.view(-1, self.nelec, 1, self.ndim) - self.atom_coords[None, ...]
 
         # distance between electrons and atoms
-        r = torch.sqrt((xyz*xyz).sum(3))
+        r = torch.sqrt((xyz * xyz).sum(3))
 
         return xyz, r
 
-    def _contract(self, bas):
+    def _contract(self, bas: torch.Tensor) -> torch.Tensor:
         """Contrat the basis set to form the atomic orbitals
 
         Args:
@@ -589,13 +659,13 @@ def _contract(self, bas):
         """
         nbatch = bas.shape[0]
         bas = self.bas_coeffs * bas
-        cbas = torch.zeros(nbatch, self.nelec,
-                           self.norb, device=self.device
-                           ).type(torch.get_default_dtype())
+        cbas = torch.zeros(nbatch, self.nelec, self.norb, device=self.device).type(
+            torch.get_default_dtype()
+        )
         cbas.index_add_(2, self.index_ctr, bas)
         return cbas
 
-    def update(self, ao, pos, idelec):
+    def update(self, ao: torch.Tensor, pos: torch.Tensor, idelec: int) -> torch.Tensor:
         """Update an AO matrix with the new positions of one electron
 
         Args:
@@ -618,6 +688,5 @@ def update(self, ao, pos, idelec):
 
         ao_new = ao.clone()
         ids, ide = (idelec) * 3, (idelec + 1) * 3
-        ao_new[:, idelec, :] = self.forward(
-            pos[:, ids:ide], one_elec=True).squeeze(1)
+        ao_new[:, idelec, :] = self.forward(pos[:, ids:ide], one_elec=True).squeeze(1)
         return ao_new
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 7ddf796b..2f44fe13 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -1,27 +1,34 @@
 import torch
-
+from typing import Optional, List, Union, Tuple
 from .atomic_orbitals import AtomicOrbitals
+from ...scf import Molecule
 from .backflow.backflow_transformation import BackFlowTransformation
 
-
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
-
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
+    def __init__(self, 
+                 mol: Molecule, 
+                 backflow: BackFlowTransformation, 
+                 cuda: Optional[bool] = False) -> None:
         """Computes the value of atomic orbitals
 
         Args:
             mol (Molecule): Molecule object
+            backflow (BackFlowTransformation): Backflow transformation
             cuda (bool, optional): Turn GPU ON/OFF Defaults to False.
         """
 
         super().__init__(mol, cuda)
-        dtype = torch.get_default_dtype()
-        self.backflow_trans = BackFlowTransformation(mol,
-                                                     backflow_kernel=backflow_kernel,
-                                                     backflow_kernel_kwargs=backflow_kernel_kwargs,
-                                                     cuda=cuda)
-
-    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
+        # dtype = torch.get_default_dtype()
+        self.backflow_trans = backflow
+
+    def forward(
+        self, 
+        pos: torch.Tensor, 
+        derivative: Optional[List[int]]=[0], 
+        sum_grad: Optional[bool] = True, 
+        sum_hess: Optional[bool] = True, 
+        one_elec: Optional[bool] = False
+    ) -> torch.Tensor:
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -73,10 +80,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             derivative = [derivative]
 
         if not sum_grad:
-            assert(1 in derivative)
+            assert 1 in derivative
 
         if not sum_hess:
-            assert(2 in derivative)
+            assert 2 in derivative
 
         if one_elec:
             nelec_save = self.nelec
@@ -86,12 +93,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             ao = self._compute_ao_values(pos)
 
         elif derivative == [1]:
-            ao = self._compute_first_derivative_ao_values(
-                pos, sum_grad)
+            ao = self._compute_first_derivative_ao_values(pos, sum_grad)
 
         elif derivative == [2]:
-            ao = self._compute_second_derivative_ao_values(
-                pos, sum_hess)
+            ao = self._compute_second_derivative_ao_values(pos, sum_hess)
 
         elif derivative == [3]:
             ao = self._compute_mixed_second_derivative_ao_values(pos)
@@ -101,14 +106,15 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
 
         else:
             raise ValueError(
-                'derivative must be 0, 1, 2 or [0, 1, 2], got ', derivative)
+                "derivative must be 0, 1, 2 or [0, 1, 2], got ", derivative
+            )
 
         if one_elec:
             self.nelec = nelec_save
 
         return ao
 
-    def _compute_first_derivative_ao_values(self, pos, sum_grad):
+    def _compute_first_derivative_ao_values(self, pos: torch.Tensor, sum_grad: bool) -> torch.Tensor:
         """Compute the value of the derivative of the ao from the xyx and r tensor
 
         Args:
@@ -128,7 +134,10 @@ def _compute_first_derivative_ao_values(self, pos, sum_grad):
 
         return grad
 
-    def _compute_gradient_backflow_ao_values(self, pos, grad_ao=None):
+    def _compute_gradient_backflow_ao_values(self, 
+                                             pos: torch.Tensor, 
+                                             grad_ao: Optional[Union[None, torch.Tensor]] = None
+                                             ) -> torch.Tensor:
         """Compute the jacobian of the backflow ao fromn xyz tensor
 
         Args:
@@ -151,7 +160,7 @@ def _compute_gradient_backflow_ao_values(self, pos, grad_ao=None):
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x 1
-        dbf = self.backflow_trans(pos, derivative=1).unsqueeze(-1)
+        dbf = self.backflow_trans(pos, derivative=1)
 
         # compute backflow : Nbatch x Ndim x Nelec x Nelec x Norb
         grad_ao = (grad_ao * dbf).sum(1)
@@ -164,7 +173,7 @@ def _compute_gradient_backflow_ao_values(self, pos, grad_ao=None):
 
         return grad_ao
 
-    def _compute_second_derivative_ao_values(self, pos, sum_hess):
+    def _compute_second_derivative_ao_values(self, pos: torch.Tensor, sum_hess: bool) -> torch.Tensor:
         """Compute the value of the 2nd derivative of the ao from the xyx and r tensor
 
         Args:
@@ -184,7 +193,13 @@ def _compute_second_derivative_ao_values(self, pos, sum_hess):
 
         return hess
 
-    def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=None, grad_ao=None):
+    def _compute_diag_hessian_backflow_ao_values(
+        self, 
+        pos: torch.Tensor, 
+        hess_ao: Optional[Union[None, torch.Tensor]] = None, 
+        mixed_ao: Optional[Union[None, torch.Tensor]] = None, 
+        grad_ao: Optional[Union[None, torch.Tensor]] = None
+    ) -> torch.Tensor:
         """Compute the laplacian of the backflow ao fromn xyz tensor
 
         Args:
@@ -199,8 +214,7 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
             hess_ao = self._compute_diag_hessian_ao_values(pos)
 
         if mixed_ao is None:
-            mixed_ao = self._compute_mixed_second_derivative_ao_values(
-                pos)
+            mixed_ao = self._compute_mixed_second_derivative_ao_values(pos)
 
         if grad_ao is None:
             grad_ao = self._compute_gradient_ao_values(pos)
@@ -219,21 +233,20 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x 1
-        dbf = self.backflow_trans(pos, derivative=1).unsqueeze(-1)
+        dbf = self.backflow_trans(pos, derivative=1)
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x 1
-        d2bf = self.backflow_trans(pos, derivative=2).unsqueeze(-1)
+        d2bf = self.backflow_trans(pos, derivative=2)
 
         # compute the back flow second der
-        hess_ao = (hess_ao * (dbf*dbf)).sum(1)
+        hess_ao = (hess_ao * (dbf * dbf)).sum(1)
 
         # compute the backflow grad
         hess_ao += (grad_ao * d2bf).sum(1)
 
         # compute the contribution of the mixed derivative
-        hess_ao += 2*(mixed_ao *
-                      dbf[:, [[0, 1], [0, 2], [1, 2]], ...].prod(2)).sum(1)
+        hess_ao += 2 * (mixed_ao * dbf[:, [[0, 1], [0, 2], [1, 2]], ...].prod(2)).sum(1)
 
         # permute to have Nelec x Ndim x Nbatch x Nelec x Norb
         hess_ao = hess_ao.permute(3, 1, 0, 2, 4)
@@ -243,7 +256,8 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
 
         return hess_ao
 
-    def _compute_all_backflow_ao_values(self, pos):
+    def _compute_all_backflow_ao_values(self, pos: torch.Tensor
+                                        ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor] :
         """Compute the ao, gradient, laplacian of the ao from the xyx and r tensor
 
         Args:
@@ -259,13 +273,19 @@ def _compute_all_backflow_ao_values(self, pos):
 
         xyz, r = self._process_position(pos)
 
-        R, dR, d2R = self.radial(r, self.bas_n, self.bas_exp,
-                                 xyz=xyz, derivative=[0, 1, 2],
-                                 sum_grad=False, sum_hess=False)
+        R, dR, d2R = self.radial(
+            r,
+            self.bas_n,
+            self.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2],
+            sum_grad=False,
+            sum_hess=False,
+        )
 
-        Y, dY, d2Y = self.harmonics(xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False, sum_hess=False)
+        Y, dY, d2Y = self.harmonics(
+            xyz, derivative=[0, 1, 2], sum_grad=False, sum_hess=False
+        )
 
         # vals of the bf ao
         ao = self._ao_kernel(R, Y)
@@ -274,20 +294,19 @@ def _compute_all_backflow_ao_values(self, pos):
         grad_ao = self._gradient_kernel(R, dR, Y, dY)
 
         # diag hess kernel of the bf ao
-        hess_ao = self._diag_hessian_kernel(
-            R, dR, d2R, Y, dY, d2Y)
+        hess_ao = self._diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y)
 
         # compute the bf ao
         hess_ao = self._compute_diag_hessian_backflow_ao_values(
-            pos, hess_ao=hess_ao, grad_ao=grad_ao)
+            pos, hess_ao=hess_ao, grad_ao=grad_ao
+        )
 
         # compute the bf grad
-        grad_ao = self._compute_gradient_backflow_ao_values(
-            pos, grad_ao=grad_ao)
+        grad_ao = self._compute_gradient_backflow_ao_values(pos, grad_ao=grad_ao)
 
         return (ao, grad_ao, hess_ao)
 
-    def _process_position(self, pos):
+    def _process_position(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/orb
 
         Args:
@@ -299,15 +318,29 @@ def _process_position(self, pos):
                                         distance between elec and bas
                                         (Nbatch, Nelec, Norb)
         """
-        # get the elec-atom vectrors/distances
-        xyz, r = self._elec_atom_dist(pos)
+        if self.backflow_trans.orbital_dependent:
+            # get the elec-atom vectrors/distances
+            xyz, r = self._elec_ao_dist(pos)
 
-        # repeat/interleave to get vector and distance between
-        # electrons and orbitals
-        return (xyz.repeat_interleave(self.nshells, dim=2),
-                r.repeat_interleave(self.nshells, dim=2))
+            if self.contract:
+                # repeat/interleave to get vector and distance between
+                # electrons and orbitals
+                xyz = xyz.repeat_interleave(self.nctr_per_ao, dim=2)
+                r = r.repeat_interleave(self.nctr_per_ao, dim=2)
 
-    def _elec_atom_dist(self, pos):
+            return (xyz, r)
+        else:
+            # get the elec-atom vectrors/distances
+            xyz, r = self._elec_atom_dist(pos)
+
+            # repeat/interleave to get vector and distance between
+            # electrons and orbitals
+            return (
+                xyz.repeat_interleave(self.nshells, dim=2),
+                r.repeat_interleave(self.nshells, dim=2),
+            )
+
+    def _elec_atom_dist(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/atoms
 
         Args:
@@ -324,10 +357,47 @@ def _elec_atom_dist(self, pos):
         bf_pos = self.backflow_trans(pos)
 
         # compute the vectors between electrons and atoms
-        xyz = (bf_pos.view(-1, self.nelec, 1, self.ndim) -
-               self.atom_coords[None, ...])
+        xyz = bf_pos.view(-1, self.nelec, 1, self.ndim) - self.atom_coords[None, ...]
+
+        # distance between electrons and atoms
+        r = torch.sqrt((xyz * xyz).sum(3))
+
+        return xyz, r
+
+    def _elec_ao_dist(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Computes the positions/distance bewteen elec/atoms
+
+        Args:
+            pos (torch.tensor): positions of the walkers Nbat, NelecxNdim
+
+        Returns:
+            torch.tensor, torch.tensor: positions of the elec wrt the bas
+                                        (Nbatch, Nelec, Natom, Ndim)
+                                        distance between elec and bas
+                                        (Nbatch, Nelec, Natom)
+        """
+
+        # compute the back flow positions
+        # Nbatch x Nao x Nelec*Ndim
+        bf_pos = self.backflow_trans(pos)
+        nbatch, nao, _ = bf_pos.shape
+
+        # reshape
+        bf_pos = bf_pos.view(nbatch, nao, self.nelec, self.ndim)
+
+        # permute to nbatch x nelec x nao x ndim
+        bf_pos = bf_pos.permute(0, 2, 1, 3)
+
+        # interleave the atomic positions
+        # nao x ndim
+        atom_coords = self.atom_coords.repeat_interleave(self.nao_per_atom, dim=0)
+
+        # compute the vectors between electrons and atoms
+        # nbatch x nelec x nao x ndim
+        xyz = bf_pos - atom_coords
 
         # distance between electrons and atoms
-        r = torch.sqrt((xyz*xyz).sum(3))
+        # nbatch x nelec x nao
+        r = torch.sqrt((xyz * xyz).sum(3))
 
         return xyz, r
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
index 9bdab418..5b87a035 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
@@ -1,11 +1,12 @@
 import torch
 
 from .atomic_orbitals import AtomicOrbitals
-from .backflow.orbital_dependent_backflow_transformation import OrbitalDependentBackFlowTransformation
+from .backflow.orbital_dependent_backflow_transformation import (
+    OrbitalDependentBackFlowTransformation,
+)
 
 
 class AtomicOrbitalsOrbitalDependentBackFlow(AtomicOrbitals):
-
     def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -15,13 +16,17 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """
 
         super().__init__(mol, cuda)
-        dtype = torch.get_default_dtype()
-        self.backflow_trans = OrbitalDependentBackFlowTransformation(mol,
-                                                                     backflow_kernel=backflow_kernel,
-                                                                     backflow_kernel_kwargs=backflow_kernel_kwargs,
-                                                                     cuda=cuda)
-
-    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
+        # dtype = torch.get_default_dtype()
+        self.backflow_trans = OrbitalDependentBackFlowTransformation(
+            mol,
+            backflow_kernel=backflow_kernel,
+            backflow_kernel_kwargs=backflow_kernel_kwargs,
+            cuda=cuda,
+        )
+
+    def forward(
+        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
+    ):
         r"""Computes the values of the atomic orbitals.
 
         .. math::
@@ -64,10 +69,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             derivative = [derivative]
 
         if not sum_grad:
-            assert(1 in derivative)
+            assert 1 in derivative
 
         if not sum_hess:
-            assert(2 in derivative)
+            assert 2 in derivative
 
         if one_elec:
             nelec_save = self.nelec
@@ -77,12 +82,10 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
             ao = self._compute_ao_values(pos)
 
         elif derivative == [1]:
-            ao = self._compute_first_derivative_ao_values(
-                pos, sum_grad)
+            ao = self._compute_first_derivative_ao_values(pos, sum_grad)
 
         elif derivative == [2]:
-            ao = self._compute_second_derivative_ao_values(
-                pos, sum_hess)
+            ao = self._compute_second_derivative_ao_values(pos, sum_hess)
 
         elif derivative == [3]:
             ao = self._compute_mixed_second_derivative_ao_values(pos)
@@ -92,7 +95,8 @@ def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=Fa
 
         else:
             raise ValueError(
-                'derivative must be 0, 1, 2 or [0, 1, 2], got ', derivative)
+                "derivative must be 0, 1, 2 or [0, 1, 2], got ", derivative
+            )
 
         if one_elec:
             self.nelec = nelec_save
@@ -142,8 +146,7 @@ def _compute_gradient_backflow_ao_values(self, pos, grad_ao=None):
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x Norb
-        dbf = self.backflow_trans(
-            pos, derivative=1).permute(0, 2, 3, 4, 5, 1)
+        dbf = self.backflow_trans(pos, derivative=1)
 
         # compute backflow : Nbatch x Ndim x Nelec x Nelec x Norb
         grad_ao = (grad_ao * dbf).sum(1)
@@ -178,7 +181,9 @@ def _compute_second_derivative_ao_values(self, pos, sum_hess):
 
         return hess
 
-    def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=None, grad_ao=None):
+    def _compute_diag_hessian_backflow_ao_values(
+        self, pos, hess_ao=None, mixed_ao=None, grad_ao=None
+    ):
         """Compute the laplacian of the backflow ao fromn xyz tensor
 
         Args:
@@ -193,8 +198,7 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
             hess_ao = self._compute_diag_hessian_ao_values(pos)
 
         if mixed_ao is None:
-            mixed_ao = self._compute_mixed_second_derivative_ao_values(
-                pos)
+            mixed_ao = self._compute_mixed_second_derivative_ao_values(pos)
 
         if grad_ao is None:
             grad_ao = self._compute_gradient_ao_values(pos)
@@ -213,23 +217,20 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x Norb
-        dbf = self.backflow_trans(
-            pos, derivative=1).permute(0, 2, 3, 4, 5, 1)
+        dbf = self.backflow_trans(pos, derivative=1)
 
         # compute the derivative of the bf positions wrt to the original pos
         # Nbatch x Ndim x Ndim x Nelec x Nelec x Norb
-        d2bf = self.backflow_trans(
-            pos, derivative=2).permute(0, 2, 3, 4, 5, 1)
+        d2bf = self.backflow_trans(pos, derivative=2)
 
         # compute the back flow second der
-        hess_ao = (hess_ao * (dbf*dbf)).sum(1)
+        hess_ao = (hess_ao * (dbf * dbf)).sum(1)
 
         # compute the backflow grad
         hess_ao += (grad_ao * d2bf).sum(1)
 
         # compute the contribution of the mixed derivative
-        hess_ao += 2*(mixed_ao *
-                      dbf[:, [[0, 1], [0, 2], [1, 2]], ...].prod(2)).sum(1)
+        hess_ao += 2 * (mixed_ao * dbf[:, [[0, 1], [0, 2], [1, 2]], ...].prod(2)).sum(1)
 
         # permute to have Nelec x Ndim x Nbatch x Nelec x Norb
         hess_ao = hess_ao.permute(3, 1, 0, 2, 4)
@@ -255,13 +256,19 @@ def _compute_all_backflow_ao_values(self, pos):
 
         xyz, r = self._process_position(pos)
 
-        R, dR, d2R = self.radial(r, self.bas_n, self.bas_exp,
-                                 xyz=xyz, derivative=[0, 1, 2],
-                                 sum_grad=False, sum_hess=False)
+        R, dR, d2R = self.radial(
+            r,
+            self.bas_n,
+            self.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2],
+            sum_grad=False,
+            sum_hess=False,
+        )
 
-        Y, dY, d2Y = self.harmonics(xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False, sum_hess=False)
+        Y, dY, d2Y = self.harmonics(
+            xyz, derivative=[0, 1, 2], sum_grad=False, sum_hess=False
+        )
 
         # vals of the bf ao
         ao = self._ao_kernel(R, Y)
@@ -270,16 +277,15 @@ def _compute_all_backflow_ao_values(self, pos):
         grad_ao = self._gradient_kernel(R, dR, Y, dY)
 
         # diag hess kernel of the bf ao
-        hess_ao = self._diag_hessian_kernel(
-            R, dR, d2R, Y, dY, d2Y)
+        hess_ao = self._diag_hessian_kernel(R, dR, d2R, Y, dY, d2Y)
 
         # compute the bf ao
         hess_ao = self._compute_diag_hessian_backflow_ao_values(
-            pos, hess_ao=hess_ao, grad_ao=grad_ao)
+            pos, hess_ao=hess_ao, grad_ao=grad_ao
+        )
 
         # compute the bf grad
-        grad_ao = self._compute_gradient_backflow_ao_values(
-            pos, grad_ao=grad_ao)
+        grad_ao = self._compute_gradient_backflow_ao_values(pos, grad_ao=grad_ao)
 
         return (ao, grad_ao, hess_ao)
 
@@ -332,15 +338,14 @@ def _elec_ao_dist(self, pos):
 
         # interleave the atomic positions
         # nao x ndim
-        atom_coords = self.atom_coords.repeat_interleave(
-            self.nao_per_atom, dim=0)
+        atom_coords = self.atom_coords.repeat_interleave(self.nao_per_atom, dim=0)
 
         # compute the vectors between electrons and atoms
         # nbatch x nelec x nao x ndim
-        xyz = (bf_pos-atom_coords)
+        xyz = bf_pos - atom_coords
 
         # distance between electrons and atoms
         # nbatch x nelec x nao
-        r = torch.sqrt((xyz*xyz).sum(3))
+        r = torch.sqrt((xyz * xyz).sum(3))
 
         return xyz, r
diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index e69de29b..372fa16e 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -0,0 +1,17 @@
+from .backflow_transformation import BackFlowTransformation
+from .kernels.backflow_kernel_base import BackFlowKernelBase
+from .kernels.backflow_kernel_autodiff_inverse import BackFlowKernelAutoInverse
+from .kernels.backflow_kernel_fully_connected import BackFlowKernelFullyConnected
+from .kernels.backflow_kernel_inverse import BackFlowKernelInverse
+from .kernels.backflow_kernel_power_sum import BackFlowKernelPowerSum
+from .kernels.backflow_kernel_square import BackFlowKernelSquare
+
+__all__ = [
+    "BackFlowTransformation",
+    "BackFlowKernelBase",
+    "BackFlowKernelAutoInverse",
+    "BackFlowKernelFullyConnected",
+    "BackFlowKernelInverse",
+    "BackFlowKernelPowerSum",
+    "BackFlowKernelSquare",
+]
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 16a92dce..291761f8 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,12 +1,21 @@
-import numpy
 import torch
 from torch import nn
+from typing import Dict, Optional
+from ....scf import Molecule
+from .kernels.backflow_kernel_base import BackFlowKernelBase
+from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
 from ...jastrows.distance.electron_electron_distance import ElectronElectronDistance
 
 
 class BackFlowTransformation(nn.Module):
-
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
+    def __init__(
+        self,
+        mol: Molecule,
+        backflow_kernel: BackFlowKernelBase,
+        backflow_kernel_kwargs: Optional[Dict] = {},
+        orbital_dependent: Optional[bool] = False,
+        cuda: Optional[bool] = False,
+    ):
         """Transform the electorn coordinates into backflow coordinates.
         see : Orbital-dependent backflow wave functions for real-space quantum Monte Carlo
         https://arxiv.org/abs/1910.07167
@@ -15,34 +24,64 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
             \\bold{q}_i = \\bold{r}_i + \\sum_{j\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
         """
         super().__init__()
-        self.backflow_kernel = backflow_kernel(mol,
-                                               cuda,
-                                               **backflow_kernel_kwargs)
-        self.edist = ElectronElectronDistance(mol.nelec)
+        self.orbital_dependent = orbital_dependent
+        self.nao = mol.basis.nao
         self.nelec = mol.nelec
         self.ndim = 3
 
+        if self.orbital_dependent:
+            self.backflow_kernel = OrbitalDependentBackFlowKernel(
+                backflow_kernel, backflow_kernel_kwargs, mol, cuda
+            )
+        else:
+            self.backflow_kernel = backflow_kernel(mol, cuda, **backflow_kernel_kwargs)
+
+        self.edist = ElectronElectronDistance(mol.nelec)
+
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
-
-    def forward(self, pos, derivative=0):
+            self.device = torch.device("cuda")
 
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: Optional[int] = 0
+                ) -> torch.Tensor:
         if derivative == 0:
-            return self._backflow(pos)
+            return self._get_backflow(pos)
 
         elif derivative == 1:
-            return self._backflow_derivative(pos)
+            return self._get_backflow_derivative(pos)
 
         elif derivative == 2:
-            return self._backflow_second_derivative(pos)
+            return self._get_backflow_second_derivative(pos)
 
         else:
             raise ValueError(
-                'derivative of the backflow transformation must be 0, 1 or 2')
+                "derivative of the backflow transformation must be 0, 1 or 2"
+            )
 
-    def _backflow(self, pos):
+    def _get_backflow(self, 
+                      pos: torch.Tensor
+                      ) -> torch.Tensor:
+        """Computes the backflow transformation
+
+        .. math:
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        Args:
+            pos(torch.tensor): original positions Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: transformed positions Nbatch x[Nelec*Ndim]
+        """
+
+        if self.orbital_dependent:
+            return self._backflow_od(pos)
+        else:
+            return self._backflow(pos)
+
+    def _backflow(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -57,20 +96,80 @@ def _backflow(self, pos):
 
         # compute the difference
         # Nbatch x Nelec x Nelec x 3
-        delta_ee = self.edist.get_difference(
-            pos.reshape(-1, self.nelec, self.ndim))
+        delta_ee = self.edist.get_difference(pos.reshape(-1, self.nelec, self.ndim))
 
         # compute the backflow function
         # Nbatch x Nelec x Nelec
         bf_kernel = self.backflow_kernel(self.edist(pos))
 
         # update pos
-        pos = pos.reshape(-1, self.nelec, self.ndim) + \
-            (bf_kernel.unsqueeze(-1) * delta_ee).sum(2)
+        pos = pos.reshape(-1, self.nelec, self.ndim) + (
+            bf_kernel.unsqueeze(-1) * delta_ee
+        ).sum(2)
+
+        return pos.reshape(-1, self.nelec * self.ndim)
 
-        return pos.reshape(-1, self.nelec*self.ndim)
+    def _backflow_od(self, pos: torch.Tensor) -> torch.Tensor:
+        """Computes the orbital dependent backflow transformation
 
-    def _backflow_derivative(self, pos):
+        .. math:
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        Args:
+            pos(torch.tensor): original positions Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: transformed positions Nbatch x[Nelec*Ndim]
+        """
+
+        nbatch = pos.shape[0]
+
+        # compute the difference
+        # Nbatch x 1 x Nelec x Nelec x 3
+        delta_ee = self.edist.get_difference(
+            pos.reshape(nbatch, self.nelec, self.ndim)
+        ).unsqueeze(1)
+
+        # compute the backflow function
+        # Nbatch x Nao x Nelec x Nelec x 1
+        bf_kernel = self.backflow_kernel(self.edist(pos)).unsqueeze(-1)
+        nao = bf_kernel.shape[self.backflow_kernel.stack_axis]
+
+        # update pos
+        pos = pos.reshape(nbatch, 1, self.nelec, self.ndim) + (
+            bf_kernel * delta_ee
+        ).sum(3)
+
+        # retrurn Nbatch x Nao x Nelec*Ndim
+        return pos.reshape(nbatch, nao, self.nelec * self.ndim)
+
+    def _get_backflow_derivative(self, pos: torch.Tensor) -> torch.Tensor:
+        r"""Computes the derivative of the backflow transformation
+           wrt the original positions of the electrons
+
+        .. math::
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        .. math::
+            \\frac{d q_i}{d x_k} = \\delta_{ik}(1 + \\sum_{j\\neq i} \\frac{d \\eta(r_ij)}{d x_i}(x_i-x_j) + \\eta(r_ij)) +
+                                   \\delta_{i\\neq k}(-\\frac{d \\eta(r_ik)}{d x_k}(x_i-x_k) - \\eta(r_ik))
+
+        Args:
+            pos(torch.tensor): orginal positions of the electrons Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: d q_{i}/d x_k with:
+                          q_{i} bf position of elec i
+                          x_k original coordinate of the kth elec
+                          Nelec x  Nbatch x Nelec x Norb x Ndim
+        """
+
+        if self.orbital_dependent:
+            return self._backflow_derivative_od(pos)
+        else:
+            return self._backflow_derivative(pos)
+
+    def _backflow_derivative(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the derivative of the backflow transformation
            wrt the original positions of the electrons
 
@@ -101,8 +200,9 @@ def _backflow_derivative(self, pos):
 
         # difference between elec pos
         # Nbatch, 3, Nelec, Nelec
-        delta_ee = self.edist.get_difference(
-            pos.reshape(nbatch, nelec, 3)).permute(0, 3, 1, 2)
+        delta_ee = self.edist.get_difference(pos.reshape(nbatch, nelec, 3)).permute(
+            0, 3, 1, 2
+        )
 
         # backflow kernel : Nbatch x 1 x Nelec x Nelec
         bf = self.backflow_kernel(ree)
@@ -118,30 +218,105 @@ def _backflow_derivative(self, pos):
 
         # compute the delta_ij * (1 + sum k \neq i eta(rik))
         # Nbatch x Nelec x Nelec (diagonal matrix)
-        delta_ij_bf = torch.diag_embed(
-            1 + bf.sum(-1), dim1=-1, dim2=-2)
+        delta_ij_bf = torch.diag_embed(1 + bf.sum(-1), dim1=-1, dim2=-2)
 
         # eye 3x3 in 1x3x3x1x1
         eye_mat = torch.eye(3, 3).view(1, 3, 3, 1, 1).to(self.device)
 
         # compute the delta_ab * delta_ij * (1 + sum k \neq i eta(rik))
         # Nbatch x Ndim x Ndim x Nelec x Nelec (diagonal matrix)
-        delta_ab_delta_ij_bf = eye_mat * \
-            delta_ij_bf.view(nbatch, 1, 1, nelec, nelec)
+        delta_ab_delta_ij_bf = eye_mat * delta_ij_bf.view(nbatch, 1, 1, nelec, nelec)
 
         # compute sum_k df(r_ik)/dbeta_i (alpha_i - alpha_k)
         # Nbatch x Ndim x Ndim x Nelec x Nelec
-        delta_ij_sum = torch.diag_embed(
-            dbf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+        delta_ij_sum = torch.diag_embed(dbf_delta_ee.sum(-1), dim1=-1, dim2=-2)
 
         # compute delta_ab * f(rij)
         delta_ab_bf = eye_mat * bf.view(nbatch, 1, 1, nelec, nelec)
 
         # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
         # nbatch d alpha_i / d beta_j
-        return delta_ab_delta_ij_bf + delta_ij_sum - dbf_delta_ee - delta_ab_bf
+        out = delta_ab_delta_ij_bf + delta_ij_sum - dbf_delta_ee - delta_ab_bf
+
+        return out.unsqueeze(-1)
+
+    def _backflow_derivative_od(self, pos:torch.Tensor) -> torch.Tensor:
+        r"""Computes the derivative of the backflow transformation
+           wrt the original positions of the electrons
+
+        .. math::
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        .. math::
+            \\frac{d q_i}{d x_k} = \\delta_{ik}(1 + \\sum_{j\\neq i} \\frac{d \\eta(r_ij)}{d x_i}(x_i-x_j) + \\eta(r_ij)) +
+                                   \\delta_{i\\neq k}(-\\frac{d \\eta(r_ik)}{d x_k}(x_i-x_k) - \\eta(r_ik))
+
+        Args:
+            pos(torch.tensor): orginal positions of the electrons Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: d q_{i}/d x_k with:
+                          q_{i} bf position of elec i
+                          x_k original coordinate of the kth elec
+                          Nelec x  Nbatch x Nelec x Norb x Ndim
+        """
+
+        # ee dist matrix : Nbatch x  Nelec x Nelec
+        ree = self.edist(pos)
+        nbatch, nelec, _ = ree.shape
+
+        # derivative ee dist matrix : Nbatch x 1 x 3 x Nelec x Nelec
+        # dr_ij / dx_i = - dr_ij / dx_j
+        dree = self.edist(pos, derivative=1).unsqueeze(1)
+
+        # difference between elec pos
+        # Nbatch, 1, 3, Nelec, Nelec
+        delta_ee = (
+            self.edist.get_difference(pos.reshape(nbatch, nelec, 3))
+            .permute(0, 3, 1, 2)
+            .unsqueeze(1)
+        )
+
+        # backflow kernel : Nbatch x Nao x Nelec x Nelec
+        bf = self.backflow_kernel(ree)
+        nao = bf.shape[self.backflow_kernel.stack_axis]
+
+        # (d eta(r_ij) / d r_ij) (d r_ij/d beta_i)
+        # derivative of the back flow kernel : Nbatch x Nao x 3 x Nelec x Nelec
+        dbf = self.backflow_kernel(ree, derivative=1).unsqueeze(2)
+        dbf = dbf * dree
+
+        # (d eta(r_ij) / d beta_i) (alpha_i - alpha_j)
+        # Nbatch x Nao x 3 x 3 x Nelec x Nelec
+        dbf_delta_ee = dbf.unsqueeze(2) * delta_ee.unsqueeze(3)
 
-    def _backflow_second_derivative(self, pos):
+        # compute the delta_ij * (1 + sum k \neq i eta(rik))
+        # Nbatch x Nao x Nelec x Nelec (diagonal matrix)
+        delta_ij_bf = torch.diag_embed(1 + bf.sum(-1), dim1=-1, dim2=-2)
+
+        # eye 3x3 in 1x3x3x1x1
+        eye_mat = torch.eye(3, 3).view(1, 1, 3, 3, 1, 1).to(self.device)
+
+        # compute the delta_ab * delta_ij * (1 + sum k \neq i eta(rik))
+        # Nbatch x Ndim x Ndim x Nelec x Nelec (diagonal matrix)
+        delta_ab_delta_ij_bf = eye_mat * delta_ij_bf.view(
+            nbatch, nao, 1, 1, nelec, nelec
+        )
+
+        # compute sum_k df(r_ik)/dbeta_i (alpha_i - alpha_k)
+        # Nbatch x Nao x Ndim x Ndim x Nelec x Nelec
+        delta_ij_sum = torch.diag_embed(dbf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+
+        # compute delta_ab * f(rij)
+        delta_ab_bf = eye_mat * bf.view(nbatch, nao, 1, 1, nelec, nelec)
+
+        # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
+        # nbatch d alpha_i / d beta_j
+        out = delta_ab_delta_ij_bf + delta_ij_sum - dbf_delta_ee - delta_ab_bf
+
+        return out.permute(0, 2, 3, 4, 5, 1)
+
+    def _get_backflow_second_derivative(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the second derivative of the backflow transformation
            wrt the original positions of the electrons
 
@@ -165,7 +340,35 @@ def _backflow_second_derivative(self, pos):
                           x_k original coordinate of the kth elec
                           Nelec x  Nbatch x Nelec x Norb x Ndim
         """
+        if self.orbital_dependent:
+            return self._backflow_second_derivative_od(pos)
+        else:
+            return self._backflow_second_derivative(pos)
+
+    def _backflow_second_derivative(self, pos: torch.Tensor) -> torch.Tensor:
+        r"""Computes the second derivative of the backflow transformation
+           wrt the original positions of the electrons
+
+        .. math::
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        .. math::
+            \\frac{d q_i}{d x_k} = \\delta_{ik}(1 + \\sum_{j\\neqi} \\frac{d \\eta(r_ij)}{d x_i} + \\eta(r_ij)) +
+                                   \\delta_{i\\neq k}(-\\frac{d \\eta(r_ik)}{d x_k} - \\eta(r_ik))
 
+        .. math::
+            \\frac{d ^ 2 q_i}{d x_k ^ 2} = \\delta_{ik}(\\sum_{j\\neqi} \\frac{d ^ 2 \\eta(r_ij)}{d x_i ^ 2} + 2 \\frac{d \\eta(r_ij)}{d x_i}) +
+                                       - \\delta_{i\\neq k}(\\frac{d ^ 2 \\eta(r_ik)}{d x_k ^ 2} + \\frac{d \\eta(r_ik)}{d x_k})
+
+        Args:
+            pos(torch.tensor): orginal positions of the electrons Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: d q_{i}/d x_k with:
+                          q_{i} bf position of elec i
+                          x_k original coordinate of the kth elec
+                          Nelec x  Nbatch x Nelec x Norb x Ndim
+        """
         # ee dist matrix :
         # Nbatch x  Nelec x Nelec
         ree = self.edist(pos)
@@ -173,8 +376,9 @@ def _backflow_second_derivative(self, pos):
 
         # difference between elec pos
         # Nbatch, 3, Nelec, Nelec
-        delta_ee = self.edist.get_difference(
-            pos.reshape(nbatch, nelec, 3)).permute(0, 3, 1, 2)
+        delta_ee = self.edist.get_difference(pos.reshape(nbatch, nelec, 3)).permute(
+            0, 3, 1, 2
+        )
 
         # derivative ee dist matrix  d r_{ij} / d x_i
         # Nbatch x 3 x Nelec x Nelec
@@ -202,13 +406,16 @@ def _backflow_second_derivative(self, pos):
         dbf = dbf * dree
 
         # eye matrix in dim x dim
-        eye_mat = torch.eye(3, 3).reshape(
-            1, 3, 3, 1, 1).to(self.device)
+        eye_mat = torch.eye(3, 3).reshape(1, 3, 3, 1, 1).to(self.device)
 
         # compute delta_ij delta_ab 2 sum_k dbf(ik) / dbeta_i
-        term1 = 2 * eye_mat * \
-            torch.diag_embed(
-                dbf.sum(-1), dim1=-1, dim2=-2).reshape(nbatch, 1, 3, nelec, nelec)
+        term1 = (
+            2
+            * eye_mat
+            * torch.diag_embed(dbf.sum(-1), dim1=-1, dim2=-2).reshape(
+                nbatch, 1, 3, nelec, nelec
+            )
+        )
 
         # (d2 eta(r_ij) / d2 beta_i) (alpha_i - alpha_j)
         # Nbatch x 3 x 3 x Nelec x Nelec
@@ -216,12 +423,111 @@ def _backflow_second_derivative(self, pos):
 
         # compute sum_k d2f(r_ik)/d2beta_i (alpha_i - alpha_k)
         # Nbatch x Ndim x Ndim x Nelec x Nelec
-        term2 = torch.diag_embed(
-            d2bf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+        term2 = torch.diag_embed(d2bf_delta_ee.sum(-1), dim1=-1, dim2=-2)
 
         # compute delta_ab * df(rij)/dbeta_j
         term3 = 2 * eye_mat * dbf.reshape(nbatch, 1, 3, nelec, nelec)
 
         # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
         # nbatch d2 alpha_i / d2 beta_j
-        return term1 + term2 + d2bf_delta_ee + term3
+        out = term1 + term2 + d2bf_delta_ee + term3
+
+        return out.unsqueeze(-1)
+
+    def _backflow_second_derivative_od(self, pos: torch.Tensor) -> torch.Tensor:
+        r"""Computes the second derivative of the backflow transformation
+           wrt the original positions of the electrons
+
+        .. math::
+            \\bold{q}_i = \\bold{r}_i + \\sum_{j\\neq i} \\eta(r_{ij})(\\bold{r}_i - \\bold{r}_j)
+
+        .. math::
+            \\frac{d q_i}{d x_k} = \\delta_{ik}(1 + \\sum_{j\\neqi} \\frac{d \\eta(r_ij)}{d x_i} + \\eta(r_ij)) +
+                                   \\delta_{i\\neq k}(-\\frac{d \\eta(r_ik)}{d x_k} - \\eta(r_ik))
+
+        .. math::
+            \\frac{d ^ 2 q_i}{d x_k ^ 2} = \\delta_{ik}(\\sum_{j\\neqi} \\frac{d ^ 2 \\eta(r_ij)}{d x_i ^ 2} + 2 \\frac{d \\eta(r_ij)}{d x_i}) +
+                                       - \\delta_{i\\neq k}(\\frac{d ^ 2 \\eta(r_ik)}{d x_k ^ 2} + \\frac{d \\eta(r_ik)}{d x_k})
+
+        Args:
+            pos(torch.tensor): orginal positions of the electrons Nbatch x[Nelec*Ndim]
+
+        Returns:
+            torch.tensor: d q_{i}/d x_k with:
+                          q_{i} bf position of elec i
+                          x_k original coordinate of the kth elec
+                          Nelec x  Nbatch x Nelec x Norb x Ndim
+        """
+
+        # ee dist matrix :
+        # Nbatch x  Nelec x Nelec
+        ree = self.edist(pos)
+        nbatch, nelec, _ = ree.shape
+
+        # difference between elec pos
+        # Nbatch, 1, 3, Nelec, Nelec
+        delta_ee = (
+            self.edist.get_difference(pos.reshape(nbatch, nelec, 3))
+            .permute(0, 3, 1, 2)
+            .unsqueeze(1)
+        )
+
+        # derivative ee dist matrix  d r_{ij} / d x_i
+        # Nbatch x 1 x 3 x Nelec x Nelec
+        dree = self.edist(pos, derivative=1).unsqueeze(1)
+
+        # derivative ee dist matrix :  d2 r_{ij} / d2 x_i
+        # Nbatch x 1 x 3 x Nelec x Nelec
+        d2ree = self.edist(pos, derivative=2).unsqueeze(1)
+
+        # derivative of the back flow kernel : d eta(r_ij)/d r_ij
+        # Nbatch x Nao x 1 x Nelec x Nelec
+        dbf = self.backflow_kernel(ree, derivative=1).unsqueeze(2)
+        nao = dbf.shape[self.backflow_kernel.stack_axis]
+
+        # second derivative of the back flow kernel : d2 eta(r_ij)/d2 r_ij
+        # Nbatch x Nao x 1 x Nelec x Nelec
+        d2bf = self.backflow_kernel(ree, derivative=2).unsqueeze(2)
+
+        # (d^2 eta(r_ij) / d r_ij^2) (d r_ij/d x_i)^2
+        # + (d eta(r_ij) / d r_ij) (d^2 r_ij/d x_i^2)
+        # Nbatch x Nao x 3 x Nelec x Nelec
+        d2bf = (d2bf * dree * dree) + (dbf * d2ree)
+
+        # (d eta(r_ij) / d r_ij) (d r_ij/d x_i)
+        # Nbatch x Nao x 3 x Nelec x Nelec
+        dbf = dbf * dree
+
+        # eye matrix in dim x dim
+        eye_mat = torch.eye(3, 3).reshape(1, 1, 3, 3, 1, 1).to(self.device)
+
+        # compute delta_ij delta_ab 2 sum_k dbf(ik) / dbeta_i
+        term1 = (
+            2
+            * eye_mat
+            * torch.diag_embed(dbf.sum(-1), dim1=-1, dim2=-2).reshape(
+                nbatch, nao, 1, 3, nelec, nelec
+            )
+        )
+
+        # (d2 eta(r_ij) / d2 beta_i) (alpha_i - alpha_j)
+        # Nbatch x Nao x 3 x 3 x Nelec x Nelec
+        d2bf_delta_ee = d2bf.unsqueeze(2) * delta_ee.unsqueeze(3)
+
+        # compute sum_k d2f(r_ik)/d2beta_i (alpha_i - alpha_k)
+        # Nbatch x Nao x Ndim x Ndim x Nelec x Nelec
+        term2 = torch.diag_embed(d2bf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+
+        # compute delta_ab * df(rij)/dbeta_j
+        term3 = 2 * eye_mat * dbf.reshape(nbatch, nao, 1, 3, nelec, nelec)
+
+        # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
+        # nbatch d2 alpha_i / d2 beta_j
+        out = term1 + term2 + d2bf_delta_ee + term3
+
+        return out.permute(0, 2, 3, 4, 5, 1)
+
+
+    def __repr__(self):
+        """representation of the backflow transformation"""
+        return self.backflow_kernel.__class__.__name__
\ No newline at end of file
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index 4b96dfc2..249d814d 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -4,3 +4,16 @@
 from .backflow_kernel_inverse import BackFlowKernelInverse
 from .backflow_kernel_power_sum import BackFlowKernelPowerSum
 from .backflow_kernel_square import BackFlowKernelSquare
+from .backflow_kernel_rbf import BackFlowKernelRBF
+from .backflow_kernel_exp import BackFlowKernelExp
+
+__all__ = [
+    "BackFlowKernelBase",
+    "BackFlowKernelAutoInverse",
+    "BackFlowKernelFullyConnected",
+    "BackFlowKernelInverse",
+    "BackFlowKernelPowerSum",
+    "BackFlowKernelSquare",
+    "BackFlowKernelRBF",
+    "BackFlowKernelExp"
+]
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
index f4479acb..2b5f00e7 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -1,11 +1,10 @@
 import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
-
+from .....scf import Molecule
 
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
-
-    def __init__(self, mol, cuda, order=2):
+    def __init__(self, mol: Molecule, cuda: bool, order: int = 2) -> None:
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -15,13 +14,12 @@ def __init__(self, mol, cuda, order=2):
         super().__init__(mol, cuda)
         self.order = order
         self.fc = nn.Linear(order, 1, bias=False)
-        self.fc.weight.data *= 0.
-        self.fc.weight.data[0, 0] = 1.
+        self.fc.weight.data *= 0.0
+        self.fc.weight.data[0, 0] = 1.0
 
-        self.weight = nn.Parameter(
-            torch.as_tensor([1E-3]))
+        self.weight = nn.Parameter(torch.as_tensor([1e-3]))
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree:torch.Tensor) -> torch.Tensor:
         """Computes the kernel via autodiff
 
         Args:
@@ -32,4 +30,4 @@ def _backflow_kernel(self, ree):
         """
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
         mask = torch.ones_like(ree) - eye
-        return self.weight * mask * (1./(ree+eye) - eye)
+        return self.weight * mask * (1.0 / (ree + eye) - eye)
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 0d220c48..5dde3648 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,11 +1,11 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
-
+from torch.autograd import grad
+from typing import Tuple, List, Union
+from .....scf import Molecule
 
 class BackFlowKernelBase(nn.Module):
-
-    def __init__(self, mol, cuda):
+    def __init__(self, mol: Molecule, cuda: bool):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -15,11 +15,11 @@ def __init__(self, mol, cuda):
         super().__init__()
         self.nelec = mol.nelec
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
-    def forward(self, ree, derivative=0):
+    def forward(self, ree: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         """Computes the desired values of the kernel
          Args:
             ree (torch.tensor): e-e distance Nbatch x Nelec x Nelec
@@ -39,10 +39,9 @@ def forward(self, ree, derivative=0):
             return self._backflow_kernel_second_derivative(ree)
 
         else:
-            raise ValueError(
-                'derivative of the kernel must be 0, 1 or 2')
+            raise ValueError("derivative of the kernel must be 0, 1 or 2")
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the kernel via autodiff
 
         Args:
@@ -51,10 +50,9 @@ def _backflow_kernel(self, ree):
         Returns:
             [type]: [description]
         """
-        raise NotImplementedError(
-            'Please implement the backflow kernel')
+        raise NotImplementedError("Please implement the backflow kernel")
 
-    def _backflow_kernel_derivative(self, ree):
+    def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the first derivative of the kernel via autodiff
 
         Args:
@@ -71,7 +69,7 @@ def _backflow_kernel_derivative(self, ree):
 
         return self._grad(kernel_val, ree)
 
-    def _backflow_kernel_second_derivative(self, ree):
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the second derivative of the kernel via autodiff
 
         Args:
@@ -84,14 +82,13 @@ def _backflow_kernel_second_derivative(self, ree):
             ree.requires_grad = True
 
         with torch.enable_grad():
-
             kernel_val = self._backflow_kernel(ree)
             hess_val, _ = self._hess(kernel_val, ree)
 
         return hess_val
 
     @staticmethod
-    def _grad(val, ree):
+    def _grad(val, ree: torch.Tensor) -> torch.Tensor:
         """Get the gradients of the kernel.
 
         Args:
@@ -100,10 +97,10 @@ def _grad(val, ree):
         Returns:
             [type]: [description]
         """
-        return grad(val, ree, grad_outputs=torch.ones_like(val))[0]
+        return grad(val, ree, grad_outputs=torch.ones_like(val), allow_unused=False)[0]
 
     @staticmethod
-    def _hess(val, ree):
+    def _hess(val, ree: torch.Tensor) -> Union[torch.Tensor, Tuple[torch.Tensor,torch.Tensor]]:
         """get the hessian of thekernel.
 
         Warning thos work only because the kernel term are dependent
@@ -113,11 +110,11 @@ def _hess(val, ree):
             pos ([type]): [description]
         """
 
-        gval = grad(val,
-                    ree,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
-
-        hval = grad(gval, ree, grad_outputs=torch.ones_like(gval))[0]
+        gval = grad(val, ree, grad_outputs=torch.ones_like(val), create_graph=True, allow_unused=False)[0]
+        hval = grad(gval, ree, grad_outputs=torch.ones_like(gval), allow_unused=True)[0]
+        
+        # if the kernel is linear, hval is None
+        if hval is None:
+            hval = torch.zeros_like(ree)
 
         return hval, gval
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
new file mode 100644
index 00000000..94fd9a33
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -0,0 +1,74 @@
+import torch
+from torch import nn
+
+from .....scf import Molecule
+from .....utils import register_extra_attributes
+from .backflow_kernel_base import BackFlowKernelBase
+
+
+class BackFlowKernelExp(BackFlowKernelBase):
+    def __init__(self, mol: Molecule, cuda: bool = False, weight: float = 0.0, alpha : float = 1.0):
+        """Compute the back flow kernel, i.e. the function
+        f(rij) where rij is the distance between electron i and j
+        This kernel is used in the backflow transformation
+        .. math:
+            q_i = r_i + \\sum_{j\\neq i} f(r_{ij}) (r_i-r_j)
+
+        with here :
+
+        .. math:
+            f(r_{ij) = \\frac{w} exp^{-\\alpha r_{ij}
+        """
+        super().__init__(mol, cuda)
+        self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
+        self.alpha = nn.Parameter(torch.as_tensor([alpha])) 
+
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
+        """Computes the backflow kernel:
+
+        .. math:
+            \\eta(r_{ij}) = exp^{-\\alpha r_{ij}}
+
+        Args:
+            r (torch.tensor): e-e distance Nbatch x Nelec x Nelec
+
+        Returns:
+            torch.tensor : f(r) Nbatch x Nelec x Nelec
+        """
+
+        # eye = torch.eye(self.nelec, self.nelec).to(self.device)
+        # mask = torch.ones_like(ree) - eye
+        return self.weight * torch.exp(-self.alpha * ree)
+
+    def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        """Computes the derivative of the kernel function
+            w.r.t r_{ij}
+        .. math::
+            \\frac{d}{dr_{ij} \\eta(r_{ij}) = -w r_{ij}^{-2}
+
+        Args:
+            ree (torch.tensor): e-e distance Nbatch x Nelec x Nelec
+
+        Returns:
+            torch.tensor : f'(r) Nbatch x Nelec x Nelec
+        """
+
+        # eye = torch.eye(self.nelec, self.nelec).to(self.device)
+        # invree = 1.0 / (ree + eye) - eye
+        return -self.weight * self.alpha *  torch.exp(-self.alpha * ree)
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        """Computes the derivative of the kernel function
+            w.r.t r_{ij}
+        .. math::
+            \\frac{d^2}{dr_{ij}^2} \\eta(r_{ij}) = 2 w r_{ij}^{-3}
+
+        Args:
+            ree (torch.tensor): e-e distance Nbatch x Nelec x Nelec
+
+        Returns:
+            torch.tensor : f''(r) Nbatch x Nelec x Nelec
+        """
+
+        # eye = torch.eye(self.nelec, self.nelec).to(self.device)
+        # invree = 1.0 / (ree + eye) - eye
+        return self.weight * self.alpha**2 *  torch.exp(-self.alpha * ree)
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
index 3820d0e9..2dfdc943 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -1,12 +1,10 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
 from .backflow_kernel_base import BackFlowKernelBase
-
+from.....scf import Molecule
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
-
-    def __init__(self, mol, cuda):
+    def __init__(self, mol: Molecule, cuda: bool):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -18,11 +16,11 @@ def __init__(self, mol, cuda):
         self.fc2 = nn.Linear(16, 1, bias=False)
         self.nl_func = torch.nn.Sigmoid()
 
-        eps = 1E-0
+        eps = 1e-0
         self.fc1.weight.data *= eps
         self.fc2.weight.data *= eps
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the kernel via autodiff
 
         Args:
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 18ce0a5a..993faaa2 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -1,11 +1,13 @@
 import torch
 from torch import nn
+
+from .....scf import Molecule
+from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
 class BackFlowKernelInverse(BackFlowKernelBase):
-
-    def __init__(self, mol, cuda=False):
+    def __init__(self, mol: Molecule, cuda: bool = False, weight: float = 0.0):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -18,10 +20,9 @@ def __init__(self, mol, cuda=False):
             f(r_{ij) = \\frac{w}{r_{ij}
         """
         super().__init__(mol, cuda)
-        self.weight = nn.Parameter(
-            torch.as_tensor([1E-3]))  # .to(self.device)
+        self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the backflow kernel:
 
         .. math:
@@ -36,9 +37,9 @@ def _backflow_kernel(self, ree):
 
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
         mask = torch.ones_like(ree) - eye
-        return self.weight * mask * (1./(ree+eye) - eye)
+        return self.weight * mask * (1.0 / (ree + eye) - eye)
 
-    def _backflow_kernel_derivative(self, ree):
+    def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the derivative of the kernel function
             w.r.t r_{ij}
         .. math::
@@ -52,10 +53,10 @@ def _backflow_kernel_derivative(self, ree):
         """
 
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
-        invree = (1./(ree+eye) - eye)
-        return - self.weight * invree * invree
+        invree = 1.0 / (ree + eye) - eye
+        return -self.weight * invree * invree
 
-    def _backflow_kernel_second_derivative(self, ree):
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the derivative of the kernel function
             w.r.t r_{ij}
         .. math::
@@ -69,5 +70,5 @@ def _backflow_kernel_second_derivative(self, ree):
         """
 
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
-        invree = (1./(ree+eye) - eye)
+        invree = 1.0 / (ree + eye) - eye
         return 2 * self.weight * invree * invree * invree
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
index 72842a9a..6cd7ab4a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -1,11 +1,10 @@
 import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
-
+from .....scf import Molecule
 
 class BackFlowKernelPowerSum(BackFlowKernelBase):
-
-    def __init__(self, mol, cuda, order=2):
+    def __init__(self, mol: Molecule, cuda: bool, order: int = 2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -15,10 +14,10 @@ def __init__(self, mol, cuda, order=2):
         super().__init__(mol, cuda)
         self.order = order
         self.fc = nn.Linear(order, 1, bias=False)
-        self.fc.weight.data *= 0.
-        self.fc.weight.data[0, 0] = 1E-4
+        self.fc.weight.data *= 0.0
+        self.fc.weight.data[0, 0] = 1e-4
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the kernel via autodiff
 
         Args:
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
new file mode 100644
index 00000000..5887be77
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -0,0 +1,137 @@
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from .....scf import Molecule
+from .....utils import register_extra_attributes
+from .backflow_kernel_base import BackFlowKernelBase
+
+class BackFlowKernelRBF(BackFlowKernelBase):
+
+    def __init__(self, mol: Molecule, cuda: bool = False, num_rbf: int = 10):
+
+        """
+        Initialize the RBF kernel
+
+        Parameters
+        ----------
+        mol : Molecule
+            Molecule object
+        num_rbf : int
+            Number of radial basis functions
+        cuda : bool
+            Whether to use CUDA or not
+
+        Attributes
+        ----------
+        centers : nn.Parameter
+            Centers of the radial basis functions
+        sigma : nn.Parameter
+            Widths of the radial basis functions
+        weight : nn.Parameter
+            Weights of the radial basis functions
+        fc : nn.Linear
+            Linear layer to compute the kernel
+        bias : nn.Parameter
+            Bias of the kernel
+        """
+        super().__init__(mol, cuda)
+        self.num_rbf = num_rbf
+
+        self.centers = nn.Parameter(torch.linspace(0, 10, num_rbf))
+        self.centers.requires_grad = True
+
+        self.sigma = nn.Parameter(torch.ones(num_rbf))
+        self.sigma.requires_grad = True
+
+        self.weight = nn.Parameter(torch.Tensor(num_rbf, 1))
+        self.weight.data.fill_(1.)
+        self.weight.requires_grad = False
+
+        self.fc = nn.Linear(num_rbf, 1, bias=False)
+        self.fc.weight.data.fill_(0.0)
+
+        self.register_parameter('bias', None)
+
+    def _gaussian_kernel(self, ree: torch.Tensor) -> torch.Tensor:
+        
+        '''Compute the RBF kernel
+        
+        Args:
+            ree (torch.tensor): Nbatch x [Nelec * Nelec]
+        
+        Returns:
+            torch.tensor: Nbatch x [Nelec * Nelec]
+        '''
+        return torch.exp(-(ree-self.centers)**2 / self.sigma)
+    
+    def _gaussian_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        '''Compute the derivative of the RBF kernel
+        
+        Args:
+            ree (torch.tensor): Nbatch x [Nelec * Nelec]
+        
+        Returns:
+            torch.tensor: Nbatch x [Nelec * Nelec]
+        '''
+        return -2*(ree-self.centers)/self.sigma * self._gaussian_kernel(ree)
+    
+    def _gaussian_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        '''Compute the second derivative of the RBF kernel
+        
+        Args:
+            ree (torch.tensor): Nbatch x [Nelec * Nelec]
+        
+        Returns:
+            torch.tensor: Nbatch x [Nelec * Nelec]
+        '''
+        kernel = self._gaussian_kernel(ree)
+        derivative = self._gaussian_kernel_derivative(ree)
+        return -2 / self.sigma * kernel  - 2*(ree-self.centers)/self.sigma * derivative
+
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
+        '''Compute the kernel
+        
+        Args:
+            ree (torch.tensor): Nbatch x Nelec x Nelec
+
+        Returns:
+            torch.tensor: Nbatch x Nelec x Nelec
+        '''
+        original_shape = ree.shape
+        x = ree.reshape(-1, 1)
+        x = F.linear(x, self.weight, self.bias)
+        x = self._gaussian_kernel(x)
+        x = self.fc(x)
+        x = x.reshape(*original_shape)
+        return x
+    
+    def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        """Compute the derivative of the kernel
+
+        Args:
+            ree (torch.tensor): Nbatch x Nelec x Nelec
+        """
+        original_shape = ree.shape
+        x = ree.reshape(-1, 1)
+        x = F.linear(x, self.weight, self.bias)
+        x = self._gaussian_kernel_derivative(x)
+        x = self.fc(x)
+        x = x.reshape(*original_shape)
+        return x
+    
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
+        """Compute the second derivative of the kernel
+
+        Args:
+            ree (torch.tensor): Nbatch x Nelec x Nelec
+        """
+        original_shape = ree.shape
+        x = ree.reshape(-1, 1)
+        x = F.linear(x, self.weight, self.bias)
+        x = self._gaussian_kernel_second_derivative(x)
+        x = self.fc(x)
+        x = x.reshape(*original_shape)
+        return x
+    
+    
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
index f090a2bd..2d4a1e01 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -1,18 +1,18 @@
 import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
-
+from .....scf import Molecule
 
 class BackFlowKernelSquare(BackFlowKernelBase):
-
-    def __init__(self, mol, cuda=False):
+    def __init__(self, mol: Molecule, cuda: bool = False):
         """Define a generic kernel to test the auto diff features."""
         super().__init__(mol, cuda)
-        eps = 1E-4
-        self.weight = nn.Parameter(
-            eps * torch.rand(self.nelec, self.nelec)).to(self.device)
+        eps = 1e-4
+        self.weight = nn.Parameter(eps * torch.rand(self.nelec, self.nelec)).to(
+            self.device
+        )
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the backflow kernel:
 
         .. math:
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 84e28e02..ad5aaf4b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -1,10 +1,15 @@
 import torch
 from torch import nn
-
+from typing import Dict
+from .kernels.backflow_kernel_base import BackFlowKernelBase
+from ....scf import Molecule
 
 class OrbitalDependentBackFlowKernel(nn.Module):
-
-    def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
+    def __init__(self, 
+                 backflow_kernel: BackFlowKernelBase, 
+                 backflow_kernel_kwargs: Dict, 
+                 mol : Molecule, 
+                 cuda: bool) -> None:
         """Compute orbital dependent back flow kernel, i.e. the functions
         f(rij) where rij is the distance between electron i and j
         This kernel is used in the backflow transformation
@@ -18,19 +23,23 @@ def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
         self.nelec = mol.nelec
         self.nao = mol.basis.nao
         self.orbital_dependent_kernel = nn.ModuleList(
-            [backflow_kernel(mol, cuda, **backflow_kernel_kwargs) for iao in range(self.nao)])
+            [
+                backflow_kernel(mol, cuda, **backflow_kernel_kwargs)
+                for iao in range(self.nao)
+            ]
+        )
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
         # domension along which the different orbitals are stacked
         # with stach_axis = 1 the resulting tensors will have dimension
         # Nbatch x Nao x ...
         self.stack_axis = 1
 
-    def forward(self, ree, derivative=0):
+    def forward(self, ree: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         """Computes the desired values of the kernels
          Args:
             ree (torch.tensor): e-e distance Nbatch x Nelec x Nelec
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index 4fcec886..b079c3ff 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -1,13 +1,17 @@
-import numpy
 import torch
 from torch import nn
+from typing import Dict
 from ...jastrows.distance.electron_electron_distance import ElectronElectronDistance
+from .kernels.backflow_kernel_base import BackFlowKernelBase
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
-
+from ....scf import Molecule
 
 class OrbitalDependentBackFlowTransformation(nn.Module):
-
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
+    def __init__(self, 
+                 mol: Molecule, 
+                 backflow_kernel: BackFlowKernelBase, 
+                 backflow_kernel_kwargs: Dict = {}, 
+                 cuda: bool=False):
         """Transform the electorn coordinates into backflow coordinates.
         see : Orbital-dependent backflow wave functions for real-space quantum Monte Carlo
         https://arxiv.org/abs/1910.07167
@@ -21,16 +25,16 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         self.nelec = mol.nelec
         self.nao = mol.basis.nao
         self.backflow_kernel = OrbitalDependentBackFlowKernel(
-            backflow_kernel, backflow_kernel_kwargs, mol, cuda)
+            backflow_kernel, backflow_kernel_kwargs, mol, cuda
+        )
         self.ndim = 3
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
-
-    def forward(self, pos, derivative=0):
+            self.device = torch.device("cuda")
 
+    def forward(self, pos: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         if derivative == 0:
             return self._backflow(pos)
 
@@ -42,9 +46,10 @@ def forward(self, pos, derivative=0):
 
         else:
             raise ValueError(
-                'Derivative of the backflow transformation must be 0, 1 or 2')
+                "Derivative of the backflow transformation must be 0, 1 or 2"
+            )
 
-    def _backflow(self, pos):
+    def _backflow(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -62,22 +67,23 @@ def _backflow(self, pos):
         # compute the difference
         # Nbatch x 1 x Nelec x Nelec x 3
         delta_ee = self.edist.get_difference(
-            pos.reshape(nbatch, self.nelec, self.ndim)).unsqueeze(1)
+            pos.reshape(nbatch, self.nelec, self.ndim)
+        ).unsqueeze(1)
 
         # compute the backflow function
         # Nbatch x Nao x Nelec x Nelec x 1
-        bf_kernel = self.backflow_kernel(
-            self.edist(pos)).unsqueeze(-1)
+        bf_kernel = self.backflow_kernel(self.edist(pos)).unsqueeze(-1)
         nao = bf_kernel.shape[self.backflow_kernel.stack_axis]
 
         # update pos
-        pos = pos.reshape(nbatch, 1, self.nelec, self.ndim) + \
-            (bf_kernel * delta_ee).sum(3)
+        pos = pos.reshape(nbatch, 1, self.nelec, self.ndim) + (
+            bf_kernel * delta_ee
+        ).sum(3)
 
         # retrurn Nbatch x Nao x Nelec*Ndim
-        return pos.reshape(nbatch, nao, self.nelec*self.ndim)
+        return pos.reshape(nbatch, nao, self.nelec * self.ndim)
 
-    def _backflow_derivative(self, pos):
+    def _backflow_derivative(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the derivative of the backflow transformation
            wrt the original positions of the electrons
 
@@ -108,8 +114,11 @@ def _backflow_derivative(self, pos):
 
         # difference between elec pos
         # Nbatch, 1, 3, Nelec, Nelec
-        delta_ee = self.edist.get_difference(
-            pos.reshape(nbatch, nelec, 3)).permute(0, 3, 1, 2).unsqueeze(1)
+        delta_ee = (
+            self.edist.get_difference(pos.reshape(nbatch, nelec, 3))
+            .permute(0, 3, 1, 2)
+            .unsqueeze(1)
+        )
 
         # backflow kernel : Nbatch x Nao x Nelec x Nelec
         bf = self.backflow_kernel(ree)
@@ -126,32 +135,29 @@ def _backflow_derivative(self, pos):
 
         # compute the delta_ij * (1 + sum k \neq i eta(rik))
         # Nbatch x Nao x Nelec x Nelec (diagonal matrix)
-        delta_ij_bf = torch.diag_embed(
-            1 + bf.sum(-1), dim1=-1, dim2=-2)
+        delta_ij_bf = torch.diag_embed(1 + bf.sum(-1), dim1=-1, dim2=-2)
 
         # eye 3x3 in 1x3x3x1x1
-        eye_mat = torch.eye(3, 3).view(
-            1, 1, 3, 3, 1, 1).to(self.device)
+        eye_mat = torch.eye(3, 3).view(1, 1, 3, 3, 1, 1).to(self.device)
 
         # compute the delta_ab * delta_ij * (1 + sum k \neq i eta(rik))
         # Nbatch x Ndim x Ndim x Nelec x Nelec (diagonal matrix)
-        delta_ab_delta_ij_bf = eye_mat * \
-            delta_ij_bf.view(nbatch, nao, 1, 1, nelec, nelec)
+        delta_ab_delta_ij_bf = eye_mat * delta_ij_bf.view(
+            nbatch, nao, 1, 1, nelec, nelec
+        )
 
         # compute sum_k df(r_ik)/dbeta_i (alpha_i - alpha_k)
         # Nbatch x Nao x Ndim x Ndim x Nelec x Nelec
-        delta_ij_sum = torch.diag_embed(
-            dbf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+        delta_ij_sum = torch.diag_embed(dbf_delta_ee.sum(-1), dim1=-1, dim2=-2)
 
         # compute delta_ab * f(rij)
-        delta_ab_bf = eye_mat * \
-            bf.view(nbatch, nao, 1, 1, nelec, nelec)
+        delta_ab_bf = eye_mat * bf.view(nbatch, nao, 1, 1, nelec, nelec)
 
         # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
         # nbatch d alpha_i / d beta_j
         return delta_ab_delta_ij_bf + delta_ij_sum - dbf_delta_ee - delta_ab_bf
 
-    def _backflow_second_derivative(self, pos):
+    def _backflow_second_derivative(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the second derivative of the backflow transformation
            wrt the original positions of the electrons
 
@@ -183,8 +189,11 @@ def _backflow_second_derivative(self, pos):
 
         # difference between elec pos
         # Nbatch, 1, 3, Nelec, Nelec
-        delta_ee = self.edist.get_difference(
-            pos.reshape(nbatch, nelec, 3)).permute(0, 3, 1, 2).unsqueeze(1)
+        delta_ee = (
+            self.edist.get_difference(pos.reshape(nbatch, nelec, 3))
+            .permute(0, 3, 1, 2)
+            .unsqueeze(1)
+        )
 
         # derivative ee dist matrix  d r_{ij} / d x_i
         # Nbatch x 1 x 3 x Nelec x Nelec
@@ -213,13 +222,16 @@ def _backflow_second_derivative(self, pos):
         dbf = dbf * dree
 
         # eye matrix in dim x dim
-        eye_mat = torch.eye(3, 3).reshape(
-            1, 1, 3, 3, 1, 1).to(self.device)
+        eye_mat = torch.eye(3, 3).reshape(1, 1, 3, 3, 1, 1).to(self.device)
 
         # compute delta_ij delta_ab 2 sum_k dbf(ik) / dbeta_i
-        term1 = 2 * eye_mat * \
-            torch.diag_embed(
-                dbf.sum(-1), dim1=-1, dim2=-2).reshape(nbatch, nao, 1, 3, nelec, nelec)
+        term1 = (
+            2
+            * eye_mat
+            * torch.diag_embed(dbf.sum(-1), dim1=-1, dim2=-2).reshape(
+                nbatch, nao, 1, 3, nelec, nelec
+            )
+        )
 
         # (d2 eta(r_ij) / d2 beta_i) (alpha_i - alpha_j)
         # Nbatch x Nao x 3 x 3 x Nelec x Nelec
@@ -227,12 +239,10 @@ def _backflow_second_derivative(self, pos):
 
         # compute sum_k d2f(r_ik)/d2beta_i (alpha_i - alpha_k)
         # Nbatch x Nao x Ndim x Ndim x Nelec x Nelec
-        term2 = torch.diag_embed(
-            d2bf_delta_ee.sum(-1), dim1=-1, dim2=-2)
+        term2 = torch.diag_embed(d2bf_delta_ee.sum(-1), dim1=-1, dim2=-2)
 
         # compute delta_ab * df(rij)/dbeta_j
-        term3 = 2 * eye_mat * \
-            dbf.reshape(nbatch, nao, 1, 3, nelec, nelec)
+        term3 = 2 * eye_mat * dbf.reshape(nbatch, nao, 1, 3, nelec, nelec)
 
         # return Nbatch x Ndim(alpha) x Ndim(beta) x Nelec(i) x Nelec(j)
         # nbatch d2 alpha_i / d2 beta_j
diff --git a/qmctorch/wavefunction/orbitals/molecular_orbitals.py b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
new file mode 100644
index 00000000..eb758041
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
@@ -0,0 +1,68 @@
+import torch
+from torch import nn
+from torch.nn.utils.parametrizations import orthogonal 
+from ...scf import Molecule
+class MolecularOrbitals(nn.Module):
+    def __init__(self, 
+                 mol: Molecule, 
+                 include_all_mo: bool, 
+                 highest_occ_mo: int, 
+                 mix_mo: bool, 
+                 orthogonalize_mo: bool, 
+                 cuda: bool):
+        
+        super(MolecularOrbitals, self).__init__()
+        dtype = torch.get_default_dtype()
+
+        self.mol = mol
+        self.mix_mo = mix_mo
+        self.orthogonalize_mo = orthogonalize_mo
+
+        self.cuda = cuda
+        self.device = torch.device("cpu")
+        if self.cuda:
+            self.device = torch.device("cuda")
+
+        self.include_all_mo = include_all_mo
+        self.highest_occ_mo = highest_occ_mo
+        self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
+
+        self.mo_scf = self.get_mo_coeffs()
+        self.mo_modifier = nn.Parameter(torch.ones_like(self.mo_scf, requires_grad=True)).type(dtype)
+
+        self.mo_mixed = None
+        if self.mix_mo:
+            self.mo_mixer.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
+            if self.orthogonalize_mo:
+                self.mo_mixer = orthogonal(self.mo_mixer)
+
+        if self.cuda:
+            self.mo_scf = self.mo_scf.to(self.device)
+            self.mo_modifier.to(self.device)
+            if self.mix_mo:
+                self.mo_mixer.to(self.device)
+
+    def get_mo_coeffs(self) -> torch.tensor:
+        """Get the molecular orbital coefficients to init the mo layer."""
+        mo_coeff = torch.as_tensor(self.mol.basis.mos).type(torch.get_default_dtype())
+        if not self.include_all_mo:
+            mo_coeff = mo_coeff[:, : self.highest_occ_mo]
+        return mo_coeff.requires_grad_(False)
+    
+    def forward(self, ao: torch.tensor) -> torch.tensor:
+        """
+        Transforms atomic orbital values into molecular orbital values using
+        the molecular orbital coefficients, mo modifier and optinally a mixed.
+
+        Args:
+            ao (torch.tensor): Atomic orbital values (Nbatch, Nelec, Nao).
+
+        Returns:
+            torch.tensor: Transformed molecular orbital values (Nbatch, Nelec, Nmo).
+        """
+
+        weight = self.mo_scf * self.mo_modifier
+        out = ao @ weight.reshape(1,*weight.shape)
+        if self.mix_mo:
+            out = self.mo_mixer(out)
+        return out
\ No newline at end of file
diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 6f3be4ff..e251caf3 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -1,8 +1,10 @@
 import torch
 import numpy as np
+import math
+from types import SimpleNamespace
 from ...utils.algebra_utils import double_factorial
 
-def atomic_orbital_norm(basis):
+def atomic_orbital_norm(basis : SimpleNamespace) -> torch.Tensor:
     """Computes the norm of the atomic orbitals
 
     Args:
@@ -17,55 +19,54 @@ def atomic_orbital_norm(basis):
     """
 
     # spherical
-    if basis.harmonics_type == 'sph':
-
-        if basis.radial_type.startswith('sto'):
+    if basis.harmonics_type == "sph":
+        if basis.radial_type.startswith("sto"):
             return norm_slater_spherical(basis.bas_n, basis.bas_exp)
 
-        elif basis.radial_type.startswith('gto'):
+        elif basis.radial_type.startswith("gto"):
             return norm_gaussian_spherical(basis.bas_n, basis.bas_exp)
 
         else:
-            raise ValueError('%s is not a valid radial_type')
+            raise ValueError("%s is not a valid radial_type")
 
     # cartesian
-    elif basis.harmonics_type == 'cart':
-
-        if basis.radial_type.startswith('sto'):
+    elif basis.harmonics_type == "cart":
+        if basis.radial_type.startswith("sto"):
             return norm_slater_cartesian(
-                basis.bas_kx,
-                basis.bas_ky,
-                basis.bas_kz,
-                basis.bas_kr,
-                basis.bas_exp)
+                basis.bas_kx, basis.bas_ky, basis.bas_kz, basis.bas_kr, basis.bas_exp
+            )
 
-        elif basis.radial_type.startswith('gto'):
+        elif basis.radial_type.startswith("gto"):
             return norm_gaussian_cartesian(
-                basis.bas_kx, basis.bas_ky, basis.bas_kz, basis.bas_exp)
+                basis.bas_kx, basis.bas_ky, basis.bas_kz, basis.bas_exp
+            )
 
         else:
-            raise ValueError('%s is not a valid radial_type')
+            raise ValueError("%s is not a valid radial_type")
+
 
+def norm_slater_spherical(bas_n: torch.Tensor, bas_exp: torch.Tensor) -> torch.Tensor:
+    """Normalization of STOs with Spherical Harmonics.
 
-def norm_slater_spherical(bas_n, bas_exp):
-    """Normalization of STOs with Sphecrical Harmonics. \n
-     * www.theochem.ru.nl/~pwormer/Knowino/knowino.org/wiki/Slater_orbital \n
-     * C Filippi,  JCP 105, 213 1996 \n
-     * Monte Carlo Methods in Ab Inition Quantum Chemistry, B.L. Hammond
+    References:
+        * www.theochem.ru.nl/~pwormer/Knowino/knowino.org/wiki/Slater_orbital
+        * C Filippi, JCP 105, 213 1996
+        * Monte Carlo Methods in Ab Initio Quantum Chemistry, B.L. Hammond
 
     Args:
-        bas_n (torch.tensor): prinicpal quantum number
-        bas_exp (torch.tensor): slater exponents
+        bas_n (torch.Tensor): Principal quantum number
+        bas_exp (torch.Tensor): Slater exponents
 
     Returns:
-        torch.tensor: normalization factor
+        torch.Tensor: Normalization factor
     """
-    nfact = torch.as_tensor([np.math.factorial(2 * n)
-                             for n in bas_n], dtype=torch.get_default_dtype())
-    return (2 * bas_exp)**bas_n * torch.sqrt(2 * bas_exp / nfact)
+    nfact = torch.as_tensor(
+        [math.factorial(2 * n) for n in bas_n], dtype=torch.get_default_dtype()
+    )
+    return (2 * bas_exp) ** bas_n * torch.sqrt(2 * bas_exp / nfact)
 
 
-def norm_gaussian_spherical(bas_n, bas_exp):
+def norm_gaussian_spherical(bas_n: torch.Tensor, bas_exp: torch.Tensor) -> torch.Tensor:
     """Normlization of GTOs with spherical harmonics. \n
      * Computational Quantum Chemistry: An interactive Intrduction to basis set theory \n
         eq : 1.14 page 23.
@@ -78,8 +79,8 @@ def norm_gaussian_spherical(bas_n, bas_exp):
         torch.tensor: normalization factor
     """
     bas_n = torch.tensor(bas_n)
-    bas_n = bas_n + 1.
-    exp1 = 0.25 * (2. * bas_n + 1.)
+    bas_n = bas_n + 1.0
+    exp1 = 0.25 * (2.0 * bas_n + 1.0)
 
     A = torch.tensor(bas_exp)**exp1
     B = 2**(2. * bas_n + 3. / 2)
@@ -89,7 +90,12 @@ def norm_gaussian_spherical(bas_n, bas_exp):
     return torch.sqrt(B / C) * A
 
 
-def norm_slater_cartesian(a, b, c, n, exp):
+def norm_slater_cartesian(a: torch.Tensor, 
+                          b: torch.Tensor, 
+                          c: torch.Tensor, 
+                          n: torch.Tensor, 
+                          exp: torch.Tensor
+                          ) -> torch.Tensor:
     """Normaliation of STos with cartesian harmonics. \n
      * Monte Carlo Methods in Ab Initio Quantum Chemistry page 279
 
@@ -105,10 +111,11 @@ def norm_slater_cartesian(a, b, c, n, exp):
     """
     lvals = a + b + c + n + 1.
 
-    lfact = torch.as_tensor([np.math.factorial(int(2 * i))
-                             for i in lvals]).type(torch.get_default_dtype())
+    lfact = torch.as_tensor([math.factorial(int(2 * i)) for i in lvals]).type(
+        torch.get_default_dtype()
+    )
 
-    prefact = 4 * np.pi * lfact / ((2 * exp)**(2 * lvals + 1))
+    prefact = 4 * np.pi * lfact / ((2 * exp) ** (2 * lvals + 1))
 
     num = torch.as_tensor(double_factorial(2 * a.astype('int') - 1) *
                           double_factorial(2 * b.astype('int') - 1) *
@@ -119,10 +126,14 @@ def norm_slater_cartesian(a, b, c, n, exp):
         double_factorial((2 * a + 2 * b + 2 * c + 1).astype('int')
            )).type(torch.get_default_dtype())
 
-    return torch.sqrt(1. / (prefact * num / denom))
+    return torch.sqrt(1.0 / (prefact * num / denom))
 
 
-def norm_gaussian_cartesian(a, b, c, exp):
+def norm_gaussian_cartesian(a: torch.Tensor, 
+                            b: torch.Tensor, 
+                            c: torch.Tensor, 
+                            exp: torch.Tensor
+                            ) -> torch.Tensor:
     """Normaliation of GTOs with cartesian harmonics. \n
      * Monte Carlo Methods in Ab Initio Quantum Chemistry page 279
 
@@ -145,4 +156,4 @@ def norm_gaussian_cartesian(a, b, c, exp):
     cm1 = (2 * c - 1).astype('int')
     z = (4 * exp)**(c / 2) / torch.sqrt(torch.as_tensor(double_factorial(cm1)))
 
-    return (pref * x * y * z).type(torch.get_default_dtype())
+    return (pref * x * y * z).type(torch.get_default_dtype())
\ No newline at end of file
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index e0070b9f..ed0f39b3 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -1,9 +1,17 @@
 import torch
+from typing import Union, List, Callable
 from ...utils import fast_power
 
 
-def radial_slater(R, bas_n, bas_exp, xyz=None,
-                  derivative=0, sum_grad=True, sum_hess=True):
+def radial_slater(
+    R: torch.Tensor,  # distance between each electron and each atom
+    bas_n: torch.Tensor,  # principal quantum number
+    bas_exp: torch.Tensor,  # exponents of the exponential
+    xyz: torch.Tensor = None,  # positions of the electrons
+    derivative: int = 0,  # degree of the derivative
+    sum_grad: bool = True,  # return the sum_grad, i.e the sum of the gradients
+    sum_hess: bool = True,  # return the sum_hess, i.e the sum of the diag hessian
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -26,9 +34,6 @@ def radial_slater(R, bas_n, bas_exp, xyz=None,
                            (default: {True})
         sum_hess (bool): return the sum_hess, i.e the sum of the diag hessian
                            (default: {False})
-        mixed_hess (bool): return the full hessian for each electron
-                            i.e. dxdy dxdz dydz ... mixed derivatives
-                           (default: {False})
 
     Returns:
         torch.tensor: values of each orbital radial part at each position
@@ -37,59 +42,65 @@ def radial_slater(R, bas_n, bas_exp, xyz=None,
     if not isinstance(derivative, list):
         derivative = [derivative]
 
-    def _kernel():
+    def _kernel() -> torch.Tensor:
         """Return the kernel."""
         return rn * er
 
-    def _first_derivative_kernel():
+    def _first_derivative_kernel() -> torch.Tensor:
         """Return the first derivative."""
         if sum_grad:
             nabla_rn_sum = nabla_rn.sum(3)
             nabla_er_sum = nabla_er.sum(3)
             return nabla_rn_sum * er + rn * nabla_er_sum
         else:
-            return nabla_rn * \
-                er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
+            return nabla_rn * er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
 
-    def _second_derivative_kernel():
-        """Return the pure second derivative i.e. d^2/dx^2 """
+    def _second_derivative_kernel() -> torch.Tensor:
+        """Return the pure second derivative i.e. d^2/dx^2"""
         if sum_hess:
-
             lap_rn = nRnm2 * (bas_n + 1)
-            lap_er = bexp_er * (bas_exp - 2. / R)
+            lap_er = bexp_er * (bas_exp - 2.0 / R)
 
-            return lap_rn * er + 2 * \
-                (nabla_rn * nabla_er).sum(3) + rn * lap_er
+            return lap_rn * er + 2 * (nabla_rn * nabla_er).sum(3) + rn * lap_er
         else:
-
-            xyz2 = xyz*xyz
+            xyz2 = xyz * xyz
             xyz2 = xyz2 / xyz2.sum(-1, keepdim=True)
 
-            lap_rn = nRnm2.unsqueeze(-1) * \
-                (1. + (bas_n-2).unsqueeze(-1) * xyz2)
+            lap_rn = nRnm2.unsqueeze(-1) * (1.0 + (bas_n - 2).unsqueeze(-1) * xyz2)
 
-            lap_er = bexp_er.unsqueeze(-1) * \
-                (bas_exp.unsqueeze(-1) * xyz2 +
-                    (-1 + xyz2)/R.unsqueeze(-1))
+            lap_er = bexp_er.unsqueeze(-1) * (
+                bas_exp.unsqueeze(-1) * xyz2 + (-1 + xyz2) / R.unsqueeze(-1)
+            )
 
-            return lap_rn * er.unsqueeze(-1) + 2 * \
-                (nabla_rn * nabla_er) + rn.unsqueeze(-1) * lap_er
+            return (
+                lap_rn * er.unsqueeze(-1)
+                + 2 * (nabla_rn * nabla_er)
+                + rn.unsqueeze(-1) * lap_er
+            )
 
-    def _mixed_second_derivative_kernel():
+    def _mixed_second_derivative_kernel() -> torch.Tensor:
         """Returns the mixed second derivative i.e. d^2/dxdy.
         where x and y are coordinate of the same electron."""
 
         mix_prod = xyz[..., [[0, 1], [0, 2], [1, 2]]].prod(-1)
-        nRnm4 = nRnm2 / (xyz*xyz).sum(-1)
-
-        lap_rn = ((bas_n-2) * nRnm4).unsqueeze(-1) * mix_prod
-
-        lap_er = (bexp_er/(xyz*xyz).sum(-1)).unsqueeze(-1) * mix_prod * (
-            bas_exp.unsqueeze(-1) + 1./R.unsqueeze(-1))
-
-        return lap_rn * er.unsqueeze(-1) \
-            + (nabla_rn[..., [[0, 1], [0, 2], [1, 2]]] * nabla_er[..., [[1, 0], [2, 0], [2, 1]]]).sum(-1) \
+        nRnm4 = nRnm2 / (xyz * xyz).sum(-1)
+
+        lap_rn = ((bas_n - 2) * nRnm4).unsqueeze(-1) * mix_prod
+
+        lap_er = (
+            (bexp_er / (xyz * xyz).sum(-1)).unsqueeze(-1)
+            * mix_prod
+            * (bas_exp.unsqueeze(-1) + 1.0 / R.unsqueeze(-1))
+        )
+
+        return (
+            lap_rn * er.unsqueeze(-1)
+            + (
+                nabla_rn[..., [[0, 1], [0, 2], [1, 2]]]
+                * nabla_er[..., [[1, 0], [2, 0], [2, 1]]]
+            ).sum(-1)
             + rn.unsqueeze(-1) * lap_er
+        )
 
     # computes the basic quantities
     rn = fast_power(R, bas_n)
@@ -97,131 +108,157 @@ def _mixed_second_derivative_kernel():
 
     # computes the grad
     if any(x in derivative for x in [1, 2, 3]):
-        Rnm2 = R**(bas_n - 2)
+        Rnm2 = R ** (bas_n - 2)
         nRnm2 = bas_n * Rnm2
         bexp_er = bas_exp * er
         nabla_rn = (nRnm2).unsqueeze(-1) * xyz
-        nabla_er = -(bexp_er).unsqueeze(-1) * \
-            xyz / R.unsqueeze(-1)
-
-    return return_required_data(derivative, _kernel,
-                                _first_derivative_kernel,
-                                _second_derivative_kernel,
-                                _mixed_second_derivative_kernel)
-
-
-def radial_gaussian(R, bas_n, bas_exp, xyz=None, derivative=[0],
-                    sum_grad=True, sum_hess=True):
+        nabla_er = -(bexp_er).unsqueeze(-1) * xyz / R.unsqueeze(-1)
+
+    return return_required_data(
+        derivative,
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    )
+
+
+def radial_gaussian(
+    R: torch.Tensor,  # distance between each electron and each atom
+    bas_n: torch.Tensor,  # principal quantum number
+    bas_exp: torch.Tensor,  # exponents of the exponential
+    xyz: torch.Tensor = None,  # positions of the electrons
+    derivative: list = [0],  # degree of the derivative
+    sum_grad: bool = True,  # return the sum of the gradients
+    sum_hess: bool = True,  # return the sum of the hessian
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     """Compute the radial part of GTOs (or its derivative).
 
-    .. math:
-        gto = r ^ n exp(-\alpha r ^ 2)
+    .. math::
+        gto = r^n exp(-\alpha r^2)
 
     Args:
-        R(torch.tensor): distance between each electron and each atom
-        bas_n(torch.tensor): principal quantum number
-        bas_exp(torch.tensor): exponents of the exponential
+        R (torch.Tensor): distance between each electron and each atom
+        bas_n (torch.Tensor): principal quantum number
+        bas_exp (torch.Tensor): exponents of the exponential
 
-    Keyword Arguments:
-        xyz(torch.tensor): positions of the electrons
-                            (needed for derivative)(default: {None})
-        derivative(int): degree of the derivative(default: {0})
-        sum_grad(bool): return the sum_grad, i.e the sum of the gradients
-                           (default: {True})
+    Keyword Args:
+        xyz (torch.Tensor): positions of the electrons
+                            (needed for derivative) (default: {None})
+        derivative (list): degree of the derivative (default: {[0]})
+                           0: value of the function
+                           1: first derivative
+                           2: pure second derivative
+                           3: mixed second derivative
+        sum_grad (bool): return the sum of the gradients (default: {True})
+        sum_hess (bool): return the sum of the hessian (default: {True})
 
     Returns:
-        torch.tensor: values of each orbital radial part at each position
+        torch.Tensor: values of each orbital radial part at each position
     """
 
     if not isinstance(derivative, list):
         derivative = [derivative]
 
-    def _kernel():
+    def _kernel() -> torch.Tensor:
         return rn * er
 
-    def _first_derivative_kernel():
-
+    def _first_derivative_kernel() -> torch.Tensor:
         if sum_grad:
             nabla_rn_sum = nabla_rn.sum(3)
             nabla_er_sum = nabla_er.sum(3)
             return nabla_rn_sum * er + rn * nabla_er_sum
         else:
-            return nabla_rn * \
-                er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
-
-    def _second_derivative_kernel():
+            return nabla_rn * er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
 
+    def _second_derivative_kernel() -> torch.Tensor:
         if sum_hess:
             lap_rn = nRnm2 * (bas_n + 1)
-            lap_er = bas_exp * er * (4*bas_exp*R2 - 6)
+            lap_er = bas_exp * er * (4 * bas_exp * R2 - 6)
 
-            return lap_rn * er + 2 * \
-                (nabla_rn * nabla_er).sum(3) + rn * lap_er
+            return lap_rn * er + 2 * (nabla_rn * nabla_er).sum(3) + rn * lap_er
 
         else:
-            xyz2 = xyz*xyz
+            xyz2 = xyz * xyz
 
-            lap_er = (bas_exp * er).unsqueeze(-1) * \
-                (4*bas_exp.unsqueeze(-1)*xyz2-2)
+            lap_er = (bas_exp * er).unsqueeze(-1) * (
+                4 * bas_exp.unsqueeze(-1) * xyz2 - 2
+            )
 
             xyz2 = xyz2 / xyz2.sum(-1, keepdim=True)
 
-            lap_rn = nRnm2.unsqueeze(-1) * \
-                (1. + (bas_n-2).unsqueeze(-1) * xyz2)
+            lap_rn = nRnm2.unsqueeze(-1) * (1.0 + (bas_n - 2).unsqueeze(-1) * xyz2)
 
-            return lap_rn * er.unsqueeze(-1) + 2 * \
-                (nabla_rn * nabla_er) + rn.unsqueeze(-1) * lap_er
+            return (
+                lap_rn * er.unsqueeze(-1)
+                + 2 * (nabla_rn * nabla_er)
+                + rn.unsqueeze(-1) * lap_er
+            )
 
-    def _mixed_second_derivative_kernel():
+    def _mixed_second_derivative_kernel() -> torch.Tensor:
         """Returns the mixed second derivative i.e. d^2/dxdy.
         where x and y are coordinate of the same electron."""
 
         mix_prod = xyz[..., [[0, 1], [0, 2], [1, 2]]].prod(-1)
-        nRnm4 = nRnm2 / (xyz*xyz).sum(-1)
+        nRnm4 = nRnm2 / (xyz * xyz).sum(-1)
 
-        lap_rn = ((bas_n-2) * nRnm4).unsqueeze(-1) * mix_prod
+        lap_rn = ((bas_n - 2) * nRnm4).unsqueeze(-1) * mix_prod
 
         lap_er = 4 * (bexp_er * bas_exp).unsqueeze(-1) * mix_prod
 
-        return lap_rn * er.unsqueeze(-1) \
-            + (nabla_rn[..., [[0, 1], [0, 2], [1, 2]]] * nabla_er[..., [[1, 0], [2, 0], [2, 1]]]).sum(-1) \
+        return (
+            lap_rn * er.unsqueeze(-1)
+            + (
+                nabla_rn[..., [[0, 1], [0, 2], [1, 2]]]
+                * nabla_er[..., [[1, 0], [2, 0], [2, 1]]]
+            ).sum(-1)
             + rn.unsqueeze(-1) * lap_er
+        )
 
-    # computes the basic  quantities
-    R2 = R*R
+    # computes the basic quantities
+    R2 = R * R
     rn = fast_power(R, bas_n)
     er = torch.exp(-bas_exp * R2)
 
     # computes the grads
     if any(x in derivative for x in [1, 2, 3]):
-
-        Rnm2 = R**(bas_n - 2)
+        Rnm2 = R ** (bas_n - 2)
         nRnm2 = bas_n * Rnm2
         bexp_er = bas_exp * er
 
         nabla_rn = (nRnm2).unsqueeze(-1) * xyz
         nabla_er = -2 * (bexp_er).unsqueeze(-1) * xyz
 
-    return return_required_data(derivative, _kernel,
-                                _first_derivative_kernel,
-                                _second_derivative_kernel,
-                                _mixed_second_derivative_kernel)
-
-
-def radial_gaussian_pure(R, bas_n, bas_exp, xyz=None, derivative=[0],
-                         sum_grad=True, sum_hess=True):
+    return return_required_data(
+        derivative,
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    )
+
+
+def radial_gaussian_pure(
+    R: torch.Tensor,  # distance between each electron and each atom
+    bas_n: torch.Tensor,  # principal quantum number
+    bas_exp: torch.Tensor,  # exponents of the exponential
+    xyz: torch.Tensor = None,  # positions of the electrons
+    derivative: List[int] = [0],  # degree of the derivative
+    sum_grad: bool = True,  # return the sum_grad, i.e the sum of the gradients
+    sum_hess: bool = True  # return the sum_hess, i.e the sum of the lapacian
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
         gto = exp(-\alpha r ^ 2)
 
     Args:
-        R(torch.tensor): distance between each electron and each atom
-        bas_n(torch.tensor): principal quantum number
-        bas_exp(torch.tensor): exponents of the exponential
+        R(torch.Tensor): distance between each electron and each atom
+        bas_n(torch.Tensor): principal quantum number (not relevant here but kept for consistency)
+        bas_exp(torch.Tensor): exponents of the exponential
 
     Keyword Arguments:
-        xyz(torch.tensor): positions of the electrons
+        xyz(torch.Tensor): positions of the electrons
                             (needed for derivative)(default: {None})
         derivative(int): degree of the derivative(default: {0})
         sum_grad(bool): return the sum_grad, i.e the sum of the gradients
@@ -230,7 +267,7 @@ def radial_gaussian_pure(R, bas_n, bas_exp, xyz=None, derivative=[0],
                            (default: {True})
 
     Returns:
-        torch.tensor: values of each orbital radial part at each position
+        torch.Tensor: values of each orbital radial part at each position
     """
 
     if not isinstance(derivative, list):
@@ -247,12 +284,13 @@ def _first_derivative_kernel():
 
     def _second_derivative_kernel():
         if sum_hess:
-            lap_er = bas_exp * er * (4*bas_exp*R2 - 6)
+            lap_er = bas_exp * er * (4 * bas_exp * R2 - 6)
             return lap_er
         else:
-            xyz2 = xyz*xyz
-            lap_er = (bas_exp * er).unsqueeze(-1) * \
-                (4*bas_exp.unsqueeze(-1)*xyz2-2)
+            xyz2 = xyz * xyz
+            lap_er = (bas_exp * er).unsqueeze(-1) * (
+                4 * bas_exp.unsqueeze(-1) * xyz2 - 2
+            )
             return lap_er
 
     def _mixed_second_derivative_kernel():
@@ -265,77 +303,89 @@ def _mixed_second_derivative_kernel():
         return lap_er
 
     # computes the basic  quantities
-    R2 = R*R
+    R2 = R * R
     er = torch.exp(-bas_exp * R2)
 
     # computes the grads
     if any(x in derivative for x in [1, 2, 3]):
-
         bexp_er = bas_exp * er
         nabla_er = -2 * (bexp_er).unsqueeze(-1) * xyz
 
-    return return_required_data(derivative, _kernel,
-                                _first_derivative_kernel,
-                                _second_derivative_kernel,
-                                _mixed_second_derivative_kernel)
-
-
-def radial_slater_pure(R, bas_n, bas_exp, xyz=None, derivative=0,
-                       sum_grad=True, sum_hess=True):
+    return return_required_data(
+        derivative,
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    )
+
+
+def radial_slater_pure(
+    R: torch.Tensor,  # distance between each electron and each atom
+    bas_n: torch.Tensor,  # principal quantum number
+    bas_exp: torch.Tensor,  # exponents of the exponential
+    xyz: torch.Tensor = None,  # positions of the electrons
+    derivative: Union[int, List[int]] = 0,  # degree of the derivative
+    sum_grad: bool = True,  # return the sum_grad, i.e the sum of the gradients
+    sum_hess: bool = True  # return the sum_hess, i.e the sum of the laplacian
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     """Compute the radial part of STOs (or its derivative).
 
-    .. math:
+    .. math::
         sto = exp(-\alpha | r |)
 
     Args:
-        R(torch.tensor): distance between each electron and each atom
-        bas_n(torch.tensor): principal quantum number
-        bas_exp(torch.tensor): exponents of the exponential
+        R (torch.Tensor): distance between each electron and each atom
+        bas_n (torch.Tensor): principal quantum number (not relevant here but kept for consistency)
+        bas_exp (torch.Tensor): exponents of the exponential
 
     Keyword Arguments:
-        xyz(torch.tensor): positions of the electrons
+        xyz (torch.Tensor): positions of the electrons
                             (needed for derivative)(default: {None})
-        derivative(int): degree of the derivative(default: {0})
-        sum_grad(bool): return the sum_grad, i.e the sum of the gradients
+        derivative (Union[int, List[int]]): degree of the derivative(default: {0})
+        sum_grad (bool): return the sum_grad, i.e the sum of the gradients
                            (default: {True})
-        sum_hess(bool): return the sum_hess, i.e the sum of the laplacian
+        sum_hess (bool): return the sum_hess, i.e the sum of the laplacian
                            (default: {True})
 
     Returns:
-        torch.tensor: values of each orbital radial part at each position
+        torch.Tensor: values of each orbital radial part at each position
     """
 
     if not isinstance(derivative, list):
         derivative = [derivative]
 
-    def _kernel():
+    def _kernel() -> torch.Tensor:
         return er
 
-    def _first_derivative_kernel():
+    def _first_derivative_kernel() -> torch.Tensor:
         if sum_grad:
             return nabla_er.sum(3)
         else:
             return nabla_er
 
-    def _second_derivative_kernel():
-
+    def _second_derivative_kernel() -> torch.Tensor:
         if sum_hess:
-            return bexp_er * (bas_exp - 2. / R)
+            return bexp_er * (bas_exp - 2.0 / R)
 
         else:
-            xyz2 = xyz*xyz / (R*R).unsqueeze(-1)
-            lap_er = bexp_er.unsqueeze(-1) * \
-                (bas_exp.unsqueeze(-1) * xyz2 - (1-xyz2)/R.unsqueeze(-1))
+            xyz2 = xyz * xyz / (R * R).unsqueeze(-1)
+            lap_er = bexp_er.unsqueeze(-1) * (
+                bas_exp.unsqueeze(-1) * xyz2 - (1 - xyz2) / R.unsqueeze(-1)
+            )
             return lap_er
 
-    def _mixed_second_derivative_kernel():
+    def _mixed_second_derivative_kernel() -> torch.Tensor:
         """Returns the mixed second derivative i.e. d^2/dxdy.
         where x and y are coordinate of the same electron."""
 
         mix_prod = xyz[..., [[0, 1], [0, 2], [1, 2]]].prod(-1)
 
-        lap_er = (bexp_er/(xyz*xyz).sum(-1)).unsqueeze(-1) * mix_prod * (
-            bas_exp.unsqueeze(-1) + 1./R.unsqueeze(-1))
+        lap_er = (
+            (bexp_er / (xyz * xyz).sum(-1)).unsqueeze(-1)
+            * mix_prod
+            * (bas_exp.unsqueeze(-1) + 1.0 / R.unsqueeze(-1))
+        )
 
         return lap_er
 
@@ -345,37 +395,44 @@ def _mixed_second_derivative_kernel():
     # computes the grad
     if any(x in derivative for x in [1, 2, 3]):
         bexp_er = bas_exp * er
-        nabla_er = -(bexp_er).unsqueeze(-1) * \
-            xyz / R.unsqueeze(-1)
-
-    return return_required_data(derivative, _kernel,
-                                _first_derivative_kernel,
-                                _second_derivative_kernel,
-                                _mixed_second_derivative_kernel)
-
-
-def return_required_data(derivative, _kernel,
-                         _first_derivative_kernel,
-                         _second_derivative_kernel,
-                         _mixed_second_derivative_kernel):
+        nabla_er = -(bexp_er).unsqueeze(-1) * xyz / R.unsqueeze(-1)
+
+    return return_required_data(
+        derivative,
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    )
+
+
+def return_required_data(
+    derivative: List[int],
+    _kernel: Callable,
+    _first_derivative_kernel: Callable,
+    _second_derivative_kernel: Callable,
+    _mixed_second_derivative_kernel: Callable,
+) -> Union[List, torch.Tensor]:
     """Returns the data contained in derivative
 
     Args:
-        derivative(list): list of the derivatives required
-        _kernel(callable): kernel of the values
-        _first_derivative_kernel(callable): kernel for 1st der
-        _second_derivative_kernel(callable): kernel for 2nd der
+        derivative (List[int]): list of the derivatives required
+        _kernel (Callable): kernel of the values
+        _first_derivative_kernel (Callable): kernel for 1st der
+        _second_derivative_kernel (Callable): kernel for 2nd der
 
     Returns:
-        list: values of the different der requried
+        Union[List, torch.Tensor]: values of the different der required
     """
 
     # prepare the output/kernel
-    output = []
-    fns = [_kernel,
-           _first_derivative_kernel,
-           _second_derivative_kernel,
-           _mixed_second_derivative_kernel]
+    output: List = []
+    fns: List[Callable] = [
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    ]
 
     # compute the requested functions
     for d in derivative:
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 8bd67029..7b63dab8 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -1,10 +1,10 @@
 import torch
+from typing import Union, List
 from ...utils import fast_power
 
 
 class Harmonics:
-
-    def __init__(self, type, **kwargs):
+    def __init__(self, type: str, **kwargs) -> None:
         """Compute spherical or cartesian harmonics and their derivatives
 
         Args:
@@ -29,97 +29,112 @@ def __init__(self, type, **kwargs):
         self.type = type
 
         # check if we need cuda
-        if 'cuda' not in kwargs:
+        if "cuda" not in kwargs:
             cuda = False
         else:
-            cuda = kwargs['cuda']
+            cuda = kwargs["cuda"]
 
         # select the device
         if cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         else:
-            self.device = torch.device('cpu')
+            self.device = torch.device("cpu")
 
         # register parameters
-        if self.type == 'sph':
-            self.bas_l = torch.as_tensor(
-                kwargs['bas_l']).to(self.device)
-            self.bas_m = torch.as_tensor(
-                kwargs['bas_m']).to(self.device)
-
-        elif self.type == 'cart':
-
-            self.bas_kx = torch.as_tensor(
-                kwargs['bas_kx']).to(self.device)
-            self.bas_ky = torch.as_tensor(
-                kwargs['bas_ky']).to(self.device)
-            self.bas_kz = torch.as_tensor(
-                kwargs['bas_kz']).to(self.device)
-
-            self.bas_k = torch.stack(
-                (self.bas_kx, self.bas_ky, self.bas_kz)).transpose(0, 1)
+        if self.type == "sph":
+            self.bas_l = torch.as_tensor(kwargs["bas_l"]).to(self.device)
+            self.bas_m = torch.as_tensor(kwargs["bas_m"]).to(self.device)
+
+        elif self.type == "cart":
+            self.bas_kx = torch.as_tensor(kwargs["bas_kx"]).to(self.device)
+            self.bas_ky = torch.as_tensor(kwargs["bas_ky"]).to(self.device)
+            self.bas_kz = torch.as_tensor(kwargs["bas_kz"]).to(self.device)
+
+            self.bas_k = torch.stack((self.bas_kx, self.bas_ky, self.bas_kz)).transpose(
+                0, 1
+            )
             self.mask_bas_k0 = self.bas_k == 0
             self.mask_bas_k2 = self.bas_k == 2
 
-    def __call__(self, xyz, derivative=[0], sum_grad=True, sum_hess=True):
+    def __call__(
+        self,
+        xyz: torch.Tensor,
+        derivative: list = [0],
+        sum_grad: bool = True,
+        sum_hess: bool = True,
+    ) -> torch.Tensor:
         """Computes the cartesian or spherical harmonics
 
-        Arguments:
-            xyz {torch.tensor} -- coordinate of each electrons from each BAS
-                                  center (Nbatch, Nelec, Nbas, Ndim)
-
-        Keyword Arguments:
-            derivative {int} -- order of the derivative (default: {0})
-            sum_grad {bool} -- return the sum of th derivative if true and
-                               grad if False (default: {True})
-            sum_hess {bool} -- return the sum of the 2nd derivative if true and
-                               grad if False (default: {True})
+        Args:
+            xyz (torch.tensor): Coordinates of each electron from each BAS center
+                                shape (Nbatch, Nelec, Nbas, Ndim)
+            derivative (list, optional): Orders of the derivative. Defaults to [0].
+            sum_grad (bool, optional): Return the sum of the derivative if True and
+                                       individual gradients if False. Defaults to True.
+            sum_hess (bool, optional): Return the sum of the 2nd derivative if True and
+                                       individual Hessians if False. Defaults to True.
 
         Raises:
-            ValueError: of type is unrecognized
+            ValueError: If type is unrecognized
 
         Returns:
-            torch.tensor -- Values or gradient of the spherical harmonics
+            torch.tensor: Values or gradient of the harmonics
         """
 
-        if self.type == 'cart':
-            return CartesianHarmonics(xyz, self.bas_k, self.mask_bas_k0, self.mask_bas_k2,
-                                      derivative, sum_grad, sum_hess)
-        elif self.type == 'sph':
+        if self.type == "cart":
+            return CartesianHarmonics(
+                xyz,
+                self.bas_k,
+                self.mask_bas_k0,
+                self.mask_bas_k2,
+                derivative,
+                sum_grad,
+                sum_hess,
+            )
+        elif self.type == "sph":
             return SphericalHarmonics(
-                xyz, self.bas_l, self.bas_m, derivative, sum_grad, sum_hess)
+                xyz, self.bas_l, self.bas_m, derivative, sum_grad, sum_hess
+            )
         else:
-            raise ValueError('Harmonics type should be cart or sph')
-
-
-def CartesianHarmonics(xyz, k, mask0, mask2, derivative=[0],
-                       sum_grad=True, sum_hess=True):
+            raise ValueError("Harmonics type should be 'cart' or 'sph'")
+
+
+def CartesianHarmonics(
+    xyz: torch.Tensor,
+    k: torch.Tensor,
+    mask0: torch.Tensor,
+    mask2: torch.Tensor,
+    derivative: list = [0],
+    sum_grad: bool = True,
+    sum_hess: bool = True
+) -> torch.Tensor:
     r"""Computes Real Cartesian Harmonics
 
     .. math::
         Y = x^{k_x} \\times y^{k_y} \\times z^{k_z}
 
     Args:
-        xyz (torch.tensor): distance between sampling points and orbital centers \n
+        xyz (torch.Tensor): Distance between sampling points and orbital centers
                             size : (Nbatch, Nelec, Nbas, Ndim)
-        k (torch.tensor): (kx,ky,kz) exponents
-        mask0 (torch.tensor): precomputed mask of k=0
-        mask2 (torch.tensor): precomputed mask of k=2
-        derivative (int, optional): degree of the derivative. Defaults to 0.
-        sum_grad (bool, optional): returns the sum of the derivative if True. Defaults to True.
-        sum_hess (bool, optional): returns the sum of the 2nd derivative if True. Defaults to True.
+        k (torch.Tensor): (kx,ky,kz) exponents
+        mask0 (torch.Tensor): Precomputed mask of k=0
+        mask2 (torch.Tensor): Precomputed mask of k=2
+        derivative (list, optional): Orders of the derivative. Defaults to [0].
+        sum_grad (bool, optional): Returns the sum of the derivative if True. Defaults to True.
+        sum_hess (bool, optional): Returns the sum of the 2nd derivative if True. Defaults to True.
+
     Returns:
-        torch.tensor: values of the harmonics at the sampling points
+        torch.Tensor: Values of the harmonics at the sampling points
     """
 
     if not isinstance(derivative, list):
         derivative = [derivative]
 
-    def _kernel():
+    def _kernel() -> torch.Tensor:
         return xyz_k.prod(-1)
 
-    def _first_derivative_kernel():
-        km1 = k-1
+    def _first_derivative_kernel() -> torch.Tensor:
+        km1 = k - 1
         km1[km1 < 0] = 0
 
         xyz_km1 = fast_power(xyz, km1)
@@ -134,8 +149,7 @@ def _first_derivative_kernel():
         else:
             return torch.stack((dx, dy, dz), dim=-1)
 
-    def _second_derivative_kernel():
-        # prepare the exponets
+    def _second_derivative_kernel() -> torch.Tensor:
         km2 = k - 2
         km2[km2 < 0] = 0
 
@@ -143,43 +157,37 @@ def _second_derivative_kernel():
 
         kx, ky, kz = k.transpose(0, 1)
 
-        d2x = kx*(kx-1) * xyz_km2[..., 0] * \
-            xyz_k[..., 1] * xyz_k[..., 2]
-        d2y = ky*(ky-1) * xyz_k[..., 0] * \
-            xyz_km2[..., 1] * xyz_k[..., 2]
-        d2z = kz*(kz-1) * xyz_k[..., 0] * \
-            xyz_k[..., 1] * xyz_km2[..., 2]
+        d2x = kx * (kx - 1) * xyz_km2[..., 0] * xyz_k[..., 1] * xyz_k[..., 2]
+        d2y = ky * (ky - 1) * xyz_k[..., 0] * xyz_km2[..., 1] * xyz_k[..., 2]
+        d2z = kz * (kz - 1) * xyz_k[..., 0] * xyz_k[..., 1] * xyz_km2[..., 2]
 
         if sum_hess:
             return d2x + d2y + d2z
         else:
             return torch.stack((d2x, d2y, d2z), dim=-1)
 
-    def _mixed_second_derivative_kernel():
-        km1 = k-1
+    def _mixed_second_derivative_kernel() -> torch.Tensor:
+        km1 = k - 1
         km1[km1 < 0] = 0
 
         xyz_km1 = fast_power(xyz, km1)
 
         kx, ky, kz = k.transpose(0, 1)
 
-        dxdy = kx * xyz_km1[..., 0] * ky * \
-            xyz_km1[..., 1] * xyz_k[..., 2]
-        dxdz = kx * xyz_km1[..., 0] * \
-            xyz_k[..., 1] * kz * xyz_km1[..., 2]
-        dydz = xyz_k[..., 0] * ky * \
-            xyz_km1[..., 1] * kz * xyz_km1[..., 2]
+        dxdy = kx * xyz_km1[..., 0] * ky * xyz_km1[..., 1] * xyz_k[..., 2]
+        dxdz = kx * xyz_km1[..., 0] * xyz_k[..., 1] * kz * xyz_km1[..., 2]
+        dydz = xyz_k[..., 0] * ky * xyz_km1[..., 1] * kz * xyz_km1[..., 2]
 
         return torch.stack((dxdy, dxdz, dydz), dim=-1)
 
-    # computes the power of the xyz
-    xyz_k = fast_power(xyz, k,  mask0, mask2)
+    xyz_k = fast_power(xyz, k, mask0, mask2)
 
-    # compute the outputs
-    fns = [_kernel,
-           _first_derivative_kernel,
-           _second_derivative_kernel,
-           _mixed_second_derivative_kernel]
+    fns = [
+        _kernel,
+        _first_derivative_kernel,
+        _second_derivative_kernel,
+        _mixed_second_derivative_kernel,
+    ]
 
     output = []
     for d in derivative:
@@ -191,43 +199,52 @@ def _mixed_second_derivative_kernel():
         return output
 
 
-def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
+def SphericalHarmonics(
+    xyz: torch.Tensor,
+    l: torch.Tensor,
+    m: torch.Tensor,
+    derivative: Union[int, List[int]] = 0,
+    sum_grad: bool = True,
+    sum_hess: bool = True,
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     r"""Compute the Real Spherical Harmonics of the AO.
 
     Args:
-        xyz (torch.tensor): distance between sampling points and orbital centers \n
+        xyz (torch.Tensor): distance between sampling points and orbital centers
                             size : (Nbatch, Nelec, Nbas, Ndim)
-        l (torch.tensor):  l quantum number
-        m (torch.tensor):  m quantum number
+        l (torch.Tensor):  l quantum number
+        m (torch.Tensor):  m quantum number
+        derivative (Union[int, List[int]], optional): order of the derivative. Defaults to 0.
+        sum_grad (bool, optional): Return the sum of the derivative if True and individual components if False. Defaults to True.
+        sum_hess (bool, optional): Not used. Defaults to True.
 
     Returns:
-        Y (torch.tensor): value of each harmonics at each points (or derivative) \n
-                          size : (Nbatch,Nelec,Nrbf) for sum_grad=True \n
-                          size : (Nbatch,Nelec,Nrbf, Ndim) for sum_grad=False
+        Y (Union[torch.Tensor, List[torch.Tensor]]): value of each harmonics at each points (or derivative)
+                                                    size : (Nbatch,Nelec,Nrbf) if sum_grad=True
+                                                    size : (Nbatch,Nelec,Nrbf, Ndim) if sum_grad=False
     """
     if not sum_hess:
         raise NotImplementedError(
-            'SphericalHarmonics cannot return individual component of the laplacian')
+            "SphericalHarmonics cannot return individual component of the laplacian"
+        )
 
     if not isinstance(derivative, list):
         derivative = [derivative]
 
-
     if sum_grad:
         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]:
-            raise ValueError(
-                'Gradient of the spherical harmonics require derivative=1')
+            raise ValueError("Gradient of the spherical harmonics require derivative=1")
         return get_grad_spherical_harmonics(xyz, l, m)
 
 
-def get_spherical_harmonics(xyz, lval, m, derivative):
+def get_spherical_harmonics(xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor, derivative: int):
     r"""Compute the Real Spherical Harmonics of the AO.
 
     Args:
@@ -235,6 +252,7 @@ def get_spherical_harmonics(xyz, lval, m, derivative):
                             size : (Nbatch, Nelec, Nbas, Ndim)
         l (torch.tensor): l quantum number
         m (torch.tensor): m quantum number
+        derivative (int): order of the derivative
 
     Returns:
         Y (torch.tensor): value of each harmonics at each points (or derivative) \n
@@ -248,53 +266,50 @@ def get_spherical_harmonics(xyz, lval, m, derivative):
     if derivative == 0:
         Y[:, :, ind] = _spherical_harmonics_l0(xyz[:, :, ind, :])
     if derivative == 1:
-        Y[:, :, ind] = _nabla_spherical_harmonics_l0(
-            xyz[:, :, ind, :])
+        Y[:, :, ind] = _nabla_spherical_harmonics_l0(xyz[:, :, ind, :])
 
     # l=1
-    indl = (lval == 1)
+    indl = lval == 1
     if torch.any(indl):
         for mval in [-1, 0, 1]:
-            indm = (m == mval)
+            indm = m == mval
             ind = (indl * indm).nonzero().view(-1)
             if len(ind > 0):
                 if derivative == 0:
-                    Y[:, :, ind] = _spherical_harmonics_l1(
-                        xyz[:, :, ind, :], mval)
+                    Y[:, :, ind] = _spherical_harmonics_l1(xyz[:, :, ind, :], mval)
                 if derivative == 1:
                     Y[:, :, ind] = _nabla_spherical_harmonics_l1(
-                        xyz[:, :, ind, :], mval)
+                        xyz[:, :, ind, :], mval
+                    )
                 if derivative == 2:
-                    Y[:, :, ind] = _lap_spherical_harmonics_l1(
-                        xyz[:, :, ind, :], mval)
+                    Y[:, :, ind] = _lap_spherical_harmonics_l1(xyz[:, :, ind, :], mval)
 
     # l=2
-    indl = (lval == 2)
+    indl = lval == 2
     if torch.any(indl):
         for mval in [-2, -1, 0, 1, 2]:
-            indm = (m == mval)
+            indm = m == mval
             ind = (indl * indm).nonzero().view(-1)
             if len(ind > 0):
                 if derivative == 0:
-                    Y[:, :, ind] = _spherical_harmonics_l2(
-                        xyz[:, :, ind, :], mval)
+                    Y[:, :, ind] = _spherical_harmonics_l2(xyz[:, :, ind, :], mval)
                 if derivative == 1:
                     Y[:, :, ind] = _nabla_spherical_harmonics_l2(
-                        xyz[:, :, ind, :], mval)
+                        xyz[:, :, ind, :], mval
+                    )
                 if derivative == 2:
-                    Y[:, :, ind] = _lap_spherical_harmonics_l2(
-                        xyz[:, :, ind, :], mval)
+                    Y[:, :, ind] = _lap_spherical_harmonics_l2(xyz[:, :, ind, :], mval)
 
     return Y
 
 
-def get_grad_spherical_harmonics(xyz, lval, m):
+def get_grad_spherical_harmonics(xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor) -> torch.Tensor:
     r"""Compute the gradient of the Real Spherical Harmonics of the AO.
 
     Args:
         xyz (torch.tensor): distance between sampling points and orbital centers \n
                             size : (Nbatch, Nelec, Nbas, Ndim)
-        l (torch.tensor): l quantum number
+        lval (torch.tensor): l quantum number
         m (torch.tensor): m quantum number
 
     Returns:
@@ -309,32 +324,31 @@ def get_grad_spherical_harmonics(xyz, lval, m):
     Y[:, :, ind, :] = _grad_spherical_harmonics_l0(xyz[:, :, ind, :])
 
     # l=1
-    indl = (lval == 1)
+    indl = lval == 1
     if torch.any(indl):
         for mval in [-1, 0, 1]:
-            indm = (m == mval)
+            indm = m == mval
             ind = (indl * indm).nonzero().view(-1)
             if len(ind > 0):
                 # _tmp = _grad_spherical_harmonics_l1(xyz[:, :, ind, :], mval)
-                Y[:, :, ind, :] = _grad_spherical_harmonics_l1(
-                    xyz[:, :, ind, :], mval)
+                Y[:, :, ind, :] = _grad_spherical_harmonics_l1(xyz[:, :, ind, :], mval)
 
     # l=2
-    indl = (lval == 2)
+    indl = lval == 2
     if torch.any(indl):
         for mval in [-2, -1, 0, 1, 2]:
-            indm = (m == mval)
+            indm = m == mval
             ind = (indl * indm).nonzero().view(-1)
             if len(ind > 0):
-                Y[:, :, ind, :] = _grad_spherical_harmonics_l2(
-                    xyz[:, :, ind, :], mval)
+                Y[:, :, ind, :] = _grad_spherical_harmonics_l2(xyz[:, :, ind, :], mval)
 
     return Y
 
+
 # =============== L0
 
 
-def _spherical_harmonics_l0(xyz):
+def _spherical_harmonics_l0(xyz: torch.Tensor) -> torch.Tensor:
     r"""Compute the l=0 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -345,7 +359,7 @@ def _spherical_harmonics_l0(xyz):
     return 0.2820948 * torch.ones_like(xyz[..., 0])
 
 
-def _nabla_spherical_harmonics_l0(xyz):
+def _nabla_spherical_harmonics_l0(xyz: torch.Tensor) -> torch.Tensor:
     r"""Compute the nabla of l=0 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -355,7 +369,7 @@ def _nabla_spherical_harmonics_l0(xyz):
     return torch.zeros_like(xyz[..., 0])
 
 
-def _grad_spherical_harmonics_l0(xyz):
+def _grad_spherical_harmonics_l0(xyz: torch.Tensor) -> torch.Tensor:
     r"""Compute the nabla of l=0 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -365,7 +379,7 @@ def _grad_spherical_harmonics_l0(xyz):
     return torch.zeros_like(xyz)
 
 
-def _lap_spherical_harmonics_l0(xyz):
+def _lap_spherical_harmonics_l0(xyz: torch.Tensor) -> torch.Tensor:
     r"""Compute the laplacian of l=0 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -374,10 +388,11 @@ def _lap_spherical_harmonics_l0(xyz):
     """
     return torch.zeros_like(xyz[..., 0])
 
+
 # =============== L1
 
 
-def _spherical_harmonics_l1(xyz, m):
+def _spherical_harmonics_l1(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the 1-1 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -393,7 +408,7 @@ def _spherical_harmonics_l1(xyz, m):
     return c * xyz[:, :, :, index[m]] / r
 
 
-def _nabla_spherical_harmonics_l1(xyz, m):
+def _nabla_spherical_harmonics_l1(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the nabla of 1-1 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -407,10 +422,10 @@ def _nabla_spherical_harmonics_l1(xyz, m):
     r = torch.sqrt((xyz**2).sum(3))
     r3 = r**3
     c = 0.4886025119029199
-    return c * (1. / r - xyz[:, :, :, index[m]] * xyz.sum(3) / r3)
+    return c * (1.0 / r - xyz[:, :, :, index[m]] * xyz.sum(3) / r3)
 
 
-def _grad_spherical_harmonics_l1(xyz, m):
+def _grad_spherical_harmonics_l1(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the nabla of 1-1 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -427,25 +442,41 @@ def _grad_spherical_harmonics_l1(xyz, m):
     p = (c / r3).unsqueeze(-1)
 
     if m == -1:
-        return p * (torch.stack([-xyz[:, :, :, 1] * xyz[:, :, :, 0],
-                                 xyz[:, :, :, 0]**2 +
-                                 xyz[:, :, :, 2]**2,
-                                 -xyz[:, :, :, 1] * xyz[:, :, :, 2]],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [
+                    -xyz[:, :, :, 1] * xyz[:, :, :, 0],
+                    xyz[:, :, :, 0] ** 2 + xyz[:, :, :, 2] ** 2,
+                    -xyz[:, :, :, 1] * xyz[:, :, :, 2],
+                ],
+                dim=-1,
+            )
+        )
     if m == 0:
-
-        return p * (torch.stack([-xyz[:, :, :, 2] * xyz[:, :, :, 0],
-                                 -xyz[:, :, :, 2] * xyz[:, :, :, 1],
-                                 xyz[:, :, :, 0]**2 + xyz[:, :, :, 1]**2],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [
+                    -xyz[:, :, :, 2] * xyz[:, :, :, 0],
+                    -xyz[:, :, :, 2] * xyz[:, :, :, 1],
+                    xyz[:, :, :, 0] ** 2 + xyz[:, :, :, 1] ** 2,
+                ],
+                dim=-1,
+            )
+        )
     if m == 1:
-        return p * (torch.stack([xyz[:, :, :, 1]**2 + xyz[:, :, :, 2]**2,
-                                 -xyz[:, :, :, 0] * xyz[:, :, :, 1],
-                                 -xyz[:, :, :, 0] * xyz[:, :, :, 2]],
-                                dim=-1))
-
-
-def _lap_spherical_harmonics_l1(xyz, m):
+        return p * (
+            torch.stack(
+                [
+                    xyz[:, :, :, 1] ** 2 + xyz[:, :, :, 2] ** 2,
+                    -xyz[:, :, :, 0] * xyz[:, :, :, 1],
+                    -xyz[:, :, :, 0] * xyz[:, :, :, 2],
+                ],
+                dim=-1,
+            )
+        )
+
+
+def _lap_spherical_harmonics_l1(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the laplacian of 1-1 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -459,12 +490,13 @@ def _lap_spherical_harmonics_l1(xyz, m):
     r = torch.sqrt((xyz**2).sum(3))
     r3 = r**3
     c = 0.4886025119029199
-    return c * (- 2 * xyz[:, :, :, index[m]] / r3)
+    return c * (-2 * xyz[:, :, :, index[m]] / r3)
+
 
 # =============== L2
 
 
-def _spherical_harmonics_l2(xyz, m):
+def _spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the l=2 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -481,19 +513,21 @@ def _spherical_harmonics_l2(xyz, m):
 
     if m == 0:
         c0 = 0.31539156525252005
-        return c0 * (-xyz[:, :, :, 0]**2 - xyz[:, :, :, 1]
-                     ** 2 + 2 * xyz[:, :, :, 2]**2) / r2
+        return (
+            c0
+            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
+            / r2
+        )
     if m == 2:
         c2 = 0.5462742152960396
-        return c2 * (xyz[:, :, :, 0]**2 - xyz[:, :, :, 1]**2) / r2
+        return c2 * (xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2) / r2
     else:
         cm = 1.0925484305920792
         index = {-2: [0, 1], -1: [1, 2], 1: [2, 0]}
-        return cm * xyz[:, :, :, index[m][0]] * \
-            xyz[:, :, :, index[m][1]] / r2
+        return cm * xyz[:, :, :, index[m][0]] * xyz[:, :, :, index[m][1]] / r2
 
 
-def _nabla_spherical_harmonics_l2(xyz, m):
+def _nabla_spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the nabla of l=2 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -513,20 +547,33 @@ def _nabla_spherical_harmonics_l2(xyz, m):
 
     if m == 0:
         c0 = 0.31539156525252005
-        return c0 * ((- 2 * xyz[:, :, :, 0] - 2 * xyz[:, :, :, 1] + 4 * xyz[:, :, :, 2]) / r2
-                     - 2 * (-xyz[:, :, :, 0]**2 - xyz[:, :, :, 1]**2 + 2 * xyz[:, :, :, 2]**2) * xyz.sum(3) / r3)
+        return c0 * (
+            (-2 * xyz[:, :, :, 0] - 2 * xyz[:, :, :, 1] + 4 * xyz[:, :, :, 2]) / r2
+            - 2
+            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
+            * xyz.sum(3)
+            / r3
+        )
     if m == 2:
         c2 = 0.5462742152960396
-        return c2 * (2 * (xyz[:, :, :, 0] - xyz[:, :, :, 1]) / r2 - 2 * (xyz[:, :, :, 0]**2
-                                                                         - xyz[:, :, :, 1]**2) * xyz.sum(3) / r3)
+        return c2 * (
+            2 * (xyz[:, :, :, 0] - xyz[:, :, :, 1]) / r2
+            - 2 * (xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2) * xyz.sum(3) / r3
+        )
     else:
         cm = 1.0925484305920792
         index = {-2: [0, 1], -1: [1, 2], 1: [2, 0]}
-        return cm * ((xyz[:, :, :, index[m][0]] + xyz[:, :, :, index[m][1]]) / r2
-                     - 2 * xyz[:, :, :, index[m][0]] * xyz[:, :, :, index[m][1]] * xyz.sum(3) / r3)
+        return cm * (
+            (xyz[:, :, :, index[m][0]] + xyz[:, :, :, index[m][1]]) / r2
+            - 2
+            * xyz[:, :, :, index[m][0]]
+            * xyz[:, :, :, index[m][1]]
+            * xyz.sum(3)
+            / r3
+        )
 
 
-def _grad_spherical_harmonics_l2(xyz, m):
+def _grad_spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the nabla of l=2 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -550,42 +597,67 @@ def _grad_spherical_harmonics_l2(xyz, m):
     if m == -2:
         c0 = 0.31539156525252005
         p = (c0 / r4).unsqueeze(-1)
-        return p * (torch.stack([y * (-x**2 + y**2 + z**2),
-                                 x * (-y**2 + x**2 + z**2),
-                                 -2 * xyz.prod(-1)],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [
+                    y * (-(x**2) + y**2 + z**2),
+                    x * (-(y**2) + x**2 + z**2),
+                    -2 * xyz.prod(-1),
+                ],
+                dim=-1,
+            )
+        )
     if m == -1:
         c0 = 0.31539156525252005
         p = (c0 / r4).unsqueeze(-1)
-        return p * (torch.stack([-2 * xyz.prod(-1),
-                                 z * (-y**2 + x**2 + z**2),
-                                 y * (-z**2 + x**2 + y**2)],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [
+                    -2 * xyz.prod(-1),
+                    z * (-(y**2) + x**2 + z**2),
+                    y * (-(z**2) + x**2 + y**2),
+                ],
+                dim=-1,
+            )
+        )
     if m == 0:
         c0 = 0.31539156525252005
         p = (c0 / r4).unsqueeze(-1)
-        return p * (torch.stack([-6 * x * z * z,
-                                 -6 * y * z * z,
-                                 6 * x * x * z + 6 * y * y * z],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [-6 * x * z * z, -6 * y * z * z, 6 * x * x * z + 6 * y * y * z], dim=-1
+            )
+        )
 
     if m == 1:
         c0 = 0.31539156525252005
         p = (c0 / r4).unsqueeze(-1)
-        return p * (torch.stack([z * (-x * x + y * y + z * z),
-                                 -2 * xyz.prod(-1),
-                                 x * (x * x + y * y - z * z)],
-                                dim=-1))
+        return p * (
+            torch.stack(
+                [
+                    z * (-x * x + y * y + z * z),
+                    -2 * xyz.prod(-1),
+                    x * (x * x + y * y - z * z),
+                ],
+                dim=-1,
+            )
+        )
     if m == 2:
         c0 = 0.5462742152960396
         p = (c0 / r4).unsqueeze(-1)
-        return p * (torch.stack([4 * x * y * y + 2 * x * z * z,
-                                 -4 * x * x * y - 2 * y * z * z,
-                                 -2 * z * (x * x - y * y)],
-                                dim=-1))
-
-
-def _lap_spherical_harmonics_l2(xyz, m):
+        return p * (
+            torch.stack(
+                [
+                    4 * x * y * y + 2 * x * z * z,
+                    -4 * x * x * y - 2 * y * z * z,
+                    -2 * z * (x * x - y * y),
+                ],
+                dim=-1,
+            )
+        )
+
+
+def _lap_spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
     r"""Compute the nabla of l=2 Spherical Harmonics
     Args:
         xyz : array (Nbatch,Nelec,Nrbf,Ndim) x,y,z, of (Point - Center)
@@ -607,15 +679,20 @@ def _lap_spherical_harmonics_l2(xyz, m):
     if m == 0:
         c0 = 0.31539156525252005
         xyz2 = xyz**2
-        return c0 * (6 / r6 * (xyz2[:, :, :, :2].sum(-1))**2 - xyz2[:, :, :, 2] * (xyz2[:, :, :, 0]
-                                                                                   + xyz2[:, :, :, 1] - 2 * xyz2[:, :, :, 2]))
+        return c0 * (
+            6 / r6 * (xyz2[:, :, :, :2].sum(-1)) ** 2
+            - xyz2[:, :, :, 2]
+            * (xyz2[:, :, :, 0] + xyz2[:, :, :, 1] - 2 * xyz2[:, :, :, 2])
+        )
     if m == 2:
         c2 = 0.5462742152960396
         xyz2 = xyz**2
-        return c2 * (6 / r6 * xyz2[:, :, :, 2] * (xyz2[:, :, :, 1] - xyz2[:, :, :, 0])
-                     + xyz2[:, :, :, 1]**2 - xyz2[:, :, :, 0]**2)
+        return c2 * (
+            6 / r6 * xyz2[:, :, :, 2] * (xyz2[:, :, :, 1] - xyz2[:, :, :, 0])
+            + xyz2[:, :, :, 1] ** 2
+            - xyz2[:, :, :, 0] ** 2
+        )
     else:
         cm = 1.0925484305920792
         index = {-2: [0, 1], -1: [1, 2], 1: [2, 0]}
-        return cm * (- 6 * xyz[:, :, :, index[m][0]]
-                     * xyz[:, :, :, index[m][1]] / r4)
+        return cm * (-6 * xyz[:, :, :, index[m][0]] * xyz[:, :, :, index[m][1]] / r4)
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 0cc8c857..bfb3ec70 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -1,49 +1,52 @@
 import torch
-
+from typing import Tuple, List
+from ...scf import Molecule
 
 class OrbitalConfigurations:
-
-    def __init__(self, mol):
-        # self.mol = mol
+    def __init__(self, mol: Molecule) -> None:
         self.nup = mol.nup
         self.ndown = mol.ndown
         self.nelec = self.nup + self.ndown
+        self.spin = mol.spin
         self.norb = mol.basis.nmo
 
-    def get_configs(self, configs):
-        """Get the configuratio in the CI expansion
+    def get_configs(self, configs: str) -> Tuple[torch.LongTensor, torch.LongTensor]:
+        """Get the configurations in the CI expansion.
 
         Args:
-            configs (str): name of the configs we want
-            mol (mol object): molecule object
+            configs (str): Name of the configs we want.
 
         Returns:
-            tuple(torch.LongTensor,torch.LongTensor): the spin up/spin down
-            electronic confs
+            Tuple[torch.LongTensor, torch.LongTensor]: The spin up/spin down
+            electronic configurations.
         """
 
         if isinstance(configs, str):
             configs = configs.lower()
 
-        if isinstance(configs, torch.Tensor):
+        if isinstance(configs, tuple):
+            assert len(configs) == 2
+            assert configs[0].shape == configs[1].shape
+            assert len(configs[0][0]) == self.nup
+            assert len(configs[0][0]) == self.ndown
             return configs
 
-        elif configs == 'ground_state':
+        elif configs == "ground_state":
             return self._get_ground_state_config()
 
-        elif configs.startswith('cas('):
+        elif configs.startswith("cas("):
             nelec, norb = eval(configs.lstrip("cas"))
             self.sanity_check(nelec, norb)
             nocc, nvirt = self._get_orb_number(nelec, norb)
             return self._get_cas_config(nocc, nvirt, nelec)
 
-        elif configs.startswith('single('):
+        elif configs.startswith("single("):
             nelec, norb = eval(configs.lstrip("single"))
             self.sanity_check(nelec, norb)
             nocc, nvirt = self._get_orb_number(nelec, norb)
             return self._get_single_config(nocc, nvirt)
 
-        elif configs.startswith('single_double('):
+        elif configs.startswith("single_double("):
             nelec, norb = eval(configs.lstrip("single_double"))
             self.sanity_check(nelec, norb)
             nocc, nvirt = self._get_orb_number(nelec, norb)
@@ -51,73 +54,80 @@ def get_configs(self, configs):
 
         else:
             print(configs, " not recognized as valid configuration")
-            print('Options are : ground_state')
-            print('              single(nelec,norb)')
-            print('              single_double(nelec,norb)')
-            print('              cas(nelec,norb)')
+            print("Options are : ground_state")
+            print("              single(nelec,norb)")
+            print("              single_double(nelec,norb)")
+            print("              cas(nelec,norb)")
+            print("              tuple(tesnor,tensor)")
             raise ValueError("Config error")
 
-    def sanity_check(self, nelec, norb):
+    def sanity_check(self, nelec: int, norb: int) -> None:
         """Check if the number of elec/orb is consistent with the
            properties of the molecule
 
         Args:
             nelec (int): required number of electrons in config
             norb (int): required number of orb in config
-
         """
         if nelec > self.nelec:
-            raise ValueError(
-                'required number of electron in config too large')
+            raise ValueError("required number of electron in config too large")
 
         if norb > self.norb:
-            raise ValueError(
-                'required number of orbitals in config too large')
+            raise ValueError("required number of orbitals in config too large")
 
-    def _get_ground_state_config(self):
-        """Return only the ground state configuration
-
-        Args:
-            mol (mol): mol object
+    def _get_ground_state_config(self) -> Tuple[torch.LongTensor, torch.LongTensor]:
+        """Return only the ground state configuration.
 
         Returns:
-            tuple(torch.LongTensor,torch.LongTensor): the spin up/spin down
-            electronic confs
+            Tuple[torch.LongTensor, torch.LongTensor]: The spin up/spin down
+            electronic configurations.
         """
         _gs_up = list(range(self.nup))
         _gs_down = list(range(self.ndown))
         cup, cdown = [_gs_up], [_gs_down]
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_config(self, nocc, nvirt):
+    def _get_single_config(self, 
+                           nocc: Tuple[int, int], 
+                           nvirt: Tuple[int, int]
+                           ) -> Tuple[torch.LongTensor, torch.LongTensor]:
         """Get the confs of the singlet conformations
 
         Args:
-            mol (mol): mol object
-            nocc (int): number of occupied orbitals in the active space
-            nvirt (int): number of virtual orbitals in the active space
+            nocc (Tuple[int,int]): number of occupied orbitals in the active space
+            nvirt (Tuple[int,int]): number of virtual orbitals in the active space
+
+        Returns:
+            Tuple[torch.LongTensor, torch.LongTensor]: The spin up/spin down
+            electronic configurations.
         """
 
         _gs_up = list(range(self.nup))
         _gs_down = list(range(self.ndown))
         cup, cdown = [_gs_up], [_gs_down]
 
-        for iocc in range(
-                self.nup - 1, self.nup - 1 - nocc, -1):
-            for ivirt in range(self.nup, self.nup + nvirt, 1):
-                _xt = self._create_excitation(
-                    _gs_up.copy(), iocc, ivirt)
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _xt, _gs_down)
+        for iocc in range(self.nup - 1, self.nup - 1 - nocc[0], -1):
+            for ivirt in range(self.nup, self.nup + nvirt[0], 1):
+                # create an excitation is spin pu
+                _xt = self._create_excitation(_gs_up.copy(), iocc, ivirt)
+
+                # append that excitation
+                cup, cdown = self._append_excitations(cup, cdown, _xt, _gs_down)
 
-                _xt = self._create_excitation(
-                    _gs_down.copy(), iocc, ivirt)
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _gs_up, _xt)
+        for iocc in range(self.ndown - 1, self.ndown - 1 - nocc[1], -1):
+            for ivirt in range(self.ndown, self.ndown + nvirt[1], 1):
+                # create an excitation is spin down
+                _xt = self._create_excitation(_gs_down.copy(), iocc, ivirt)
+
+                # append that excitation
+                cup, cdown = self._append_excitations(cup, cdown, _gs_up, _xt)
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_double_config(self, nocc, nvirt):
+    def _get_single_double_config(self, 
+                           nocc: Tuple[int, int], 
+                           nvirt: Tuple[int, int]
+                           ) -> Tuple[torch.LongTensor, torch.LongTensor]:
         """Get the confs of the single + double
 
         Args:
@@ -131,51 +141,48 @@ def _get_single_double_config(self, nocc, nvirt):
         cup = cup.tolist()
         cdown = cdown.tolist()
 
-        idx_occ_up = list(
-            range(self.nup - 1, self.nup - 1 - nocc, -1))
-        idx_vrt_up = list(range(self.nup, self.nup + nvirt, 1))
+        idx_occ_up = list(range(self.nup - 1, self.nup - 1 - nocc[0], -1))
+        idx_vrt_up = list(range(self.nup, self.nup + nvirt[0], 1))
 
-        idx_occ_down = list(range(
-            self.ndown - 1, self.ndown - 1 - nocc, -1))
-        idx_vrt_down = list(range(self.ndown, self.ndown + nvirt, 1))
+        idx_occ_down = list(range(self.ndown - 1, self.ndown - 1 - nocc[1], -1))
+        idx_vrt_down = list(range(self.ndown, self.ndown + nvirt[1], 1))
 
         # ground, single and double with 1 elec excited per spin
         for iocc_up in idx_occ_up:
             for ivirt_up in idx_vrt_up:
-
                 for iocc_down in idx_occ_down:
                     for ivirt_down in idx_vrt_down:
-
                         _xt_up = self._create_excitation(
-                            _gs_up.copy(), iocc_up, ivirt_up)
+                            _gs_up.copy(), iocc_up, ivirt_up
+                        )
                         _xt_down = self._create_excitation(
-                            _gs_down.copy(), iocc_down, ivirt_down)
+                            _gs_down.copy(), iocc_down, ivirt_down
+                        )
                         cup, cdown = self._append_excitations(
-                            cup, cdown, _xt_up, _xt_down)
+                            cup, cdown, _xt_up, _xt_down
+                        )
 
         # double with 2elec excited on spin up
         for occ1, occ2 in torch.combinations(torch.as_tensor(idx_occ_up), r=2):
             for vrt1, vrt2 in torch.combinations(torch.as_tensor(idx_vrt_up), r=2):
-                _xt_up = self._create_excitation(
-                    _gs_up.copy(), occ1, vrt2)
+                _xt_up = self._create_excitation(_gs_up.copy(), occ1, vrt2)
                 _xt_up = self._create_excitation(_xt_up, occ2, vrt1)
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _xt_up, _gs_down)
+                cup, cdown = self._append_excitations(cup, cdown, _xt_up, _gs_down)
 
         # double with 2elec excited per spin
         for occ1, occ2 in torch.combinations(torch.as_tensor(idx_occ_down), r=2):
             for vrt1, vrt2 in torch.combinations(torch.as_tensor(idx_vrt_down), r=2):
-
-                _xt_down = self._create_excitation(
-                    _gs_down.copy(), occ1, vrt2)
-                _xt_down = self._create_excitation(
-                    _xt_down, occ2, vrt1)
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _gs_up, _xt_down)
+                _xt_down = self._create_excitation(_gs_down.copy(), occ1, vrt2)
+                _xt_down = self._create_excitation(_xt_down, occ2, vrt1)
+                cup, cdown = self._append_excitations(cup, cdown, _gs_up, _xt_down)
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_cas_config(self, nocc, nvirt, nelec):
+    def _get_cas_config(self, 
+                        nocc: Tuple[int, int], 
+                        nvirt: Tuple[int, int], 
+                        nelec: int
+                        ) -> Tuple[torch.LongTensor, torch.LongTensor]:
         """get confs of the CAS
 
         Args:
@@ -184,18 +191,21 @@ def _get_cas_config(self, nocc, nvirt, nelec):
         """
         from itertools import combinations, product
 
-        idx_low, idx_high = self.nup - nocc, self.nup + nvirt
+        if self.spin != 0:
+            raise ValueError(
+                "CAS active space not possible with spin polarized calculation"
+            )
+
+        idx_low, idx_high = self.nup - nocc[0], self.nup + nvirt[0]
         orb_index_up = range(idx_low, idx_high)
         idx_frz = list(range(idx_low))
-        _cup = [idx_frz + list(l)
-                for l in list(combinations(orb_index_up, nelec // 2))]
+        _cup = [idx_frz + list(l) for l in list(combinations(orb_index_up, nelec // 2))]
 
-        idx_low, idx_high = self.nup - nocc - 1, self.nup + nvirt - 1
+        idx_low, idx_high = self.nup - nocc[0] - 1, self.nup + nvirt[0] - 1
 
         _cdown = [
-            idx_frz +
-            list(l) for l in list(
-                combinations(orb_index_up, nelec // 2))]
+            idx_frz + list(l) for l in list(combinations(orb_index_up, nelec // 2))
+        ]
 
         confs = list(product(_cup, _cdown))
         cup, cdown = [], []
@@ -206,7 +216,7 @@ def _get_cas_config(self, nocc, nvirt, nelec):
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_orb_number(self, nelec, norb):
+    def _get_orb_number(self, nelec: int, norb: int) -> Tuple[Tuple[int, int], Tuple[int,int]]:
         """compute the number of occupied and virtual orbital
         __ PER SPIN __
         __ ONLY VALID For spin up/down ___
@@ -215,28 +225,45 @@ def _get_orb_number(self, nelec, norb):
             norb (int): total number of orb in the CAS
 
         Returns:
-            [int,int]: number of occpuied/virtual orb per spi
+            [int,int]: number of occpuied/virtual orb per spin
         """
 
-        nocc = nelec // 2
-        nvirt = norb - nocc
+        # determine the number of occupied mo per spin in the active space
+        if nelec % 2 == 0:
+            nocc = (nelec // 2, nelec // 2)
+        else:
+            nocc = (nelec // 2 + 1, nelec // 2)
+
+        # determine the number of virt mo per spin in the active space
+        nvirt = (norb - nocc[0], norb - nocc[1])
         return nocc, nvirt
 
-    def _create_excitation(self, conf, iocc, ivirt):
+    def _create_excitation(self, conf: List[int], iocc: int, ivirt: int) -> List[int]:
+        """promote an electron from iocc to ivirt
+
+        Args:
+            conf (list): index of the occupied orbitals
+            iocc (int): index of the occupied orbital
+            ivirt (int): index of the virtual orbital
+
+        Returns:
+            list: new configuration by replacing the iocc index with ivirt
+        """
         return self._create_excitation_replace(conf, iocc, ivirt)
 
     @staticmethod
-    def _create_excitation_ordered(conf, iocc, ivirt):
+    def _create_excitation_ordered(conf: List[int], iocc: int, ivirt: int) -> List[int]:
         """promote an electron from iocc to ivirt
 
         Args:
-            conf (list): index of the occupied orbitals
+            conf (List[int]): index of the occupied orbitals
             iocc (int): index of the occupied orbital
             ivirt (int): index of the virtual orbital
 
         Returns:
-            list: new configuration by increasing order
-                  e.g: 4->6 leads to : [0,1,2,3,5,6]
+            List[int]: new configuration by increasing order
+                       e.g: 4->6 leads to : [0,1,2,3,5,6]
+
         Note:
             if that method is used to define the exciation index
             permutation must be accounted for when  computing
@@ -245,55 +272,61 @@ def _create_excitation_ordered(conf, iocc, ivirt):
             see : ExcitationMask.get_index_unique_single()
                   in oribtal_projector.py
         """
-        conf.pop(iocc)
-        conf += [ivirt]
-        return conf
 
     @staticmethod
-    def _create_excitation_replace(conf, iocc, ivirt):
+    def _create_excitation_replace(conf: List[int], iocc: int, ivirt: int) -> List[int]:
         """promote an electron from iocc to ivirt
 
         Args:
-            conf (list): index of the occupied orbitals
+            conf (List[int]): index of the occupied orbitals
             iocc (int): index of the occupied orbital
             ivirt (int): index of the virtual orbital
 
         Returns:
-            list: new configuration not ordered
+            List[int]: new configuration not ordered
                 e.g.: 4->6 leads tpo : [0,1,2,3,6,5]
         """
         conf[iocc] = ivirt
         return conf
 
     @staticmethod
-    def _append_excitations(cup, cdown, new_cup, new_cdown):
+    def _append_excitations(
+        cup: List[List[int]], cdown: List[List[int]], new_cup: List[int], new_cdown: List[int]
+    ) -> Tuple[List[List[int]], List[List[int]]]:
         """Append new excitations
 
         Args:
-            cup (list): configurations of spin up
-            cdown (list): configurations of spin down
-            new_cup (list): new spin up confs
-            new_cdown (list): new spin down confs
-        """
+            cup: configurations of spin up
+            cdown: configurations of spin down
+            new_cup: new spin up confs
+            new_cdown: new spin down confs
 
+        Returns:
+            cup: updated list of spin up confs
+            cdown: updated list of spin down confs
+        """
         cup.append(new_cup)
         cdown.append(new_cdown)
         return cup, cdown
 
 
-def get_excitation(configs):
-    """get the excitation data
+def get_excitation(
+    configs: Tuple[torch.LongTensor, torch.LongTensor]
+) -> Tuple[List[List[List[int]]], List[List[List[int]]]]:
+    """Get the excitation data
 
     Args:
-        configs (tuple): configuratin of the electrons
+        configs: tuple of two tensors of shape (nconfig, norb)
+            configuratin of the electrons
 
     Returns:
-        exc_up, exc_down : index of the obitals in the excitaitons
-                            [i,j],[l,m] : excitation i -> l, j -> l
+        exc_up, exc_down : two lists of lists of lists of integers
+            excitation i -> l, j -> l
+            exc_up[i][0] : occupied orbital, exc_up[i][1] : virtual orbital
+            exc_down[i][0] : occupied orbital, exc_down[i][1] : virtual orbital
     """
     exc_up, exc_down = [], []
     for ic, (cup, cdown) in enumerate(zip(configs[0], configs[1])):
-
         set_cup = set(tuple(cup.tolist()))
         set_cdown = set(tuple(cdown.tolist()))
 
@@ -302,35 +335,42 @@ def get_excitation(configs):
             set_gs_down = set_cdown
 
         else:
-            exc_up.append([list(set_gs_up.difference(set_cup)),
-                           list(set_cup.difference(set_gs_up))])
-
-            exc_down.append([list(set_gs_down.difference(set_cdown)),
-                             list(set_cdown.difference(set_gs_down))])
+            exc_up.append(
+                [
+                    list(set_gs_up.difference(set_cup)),
+                    list(set_cup.difference(set_gs_up)),
+                ]
+            )
+
+            exc_down.append(
+                [
+                    list(set_gs_down.difference(set_cdown)),
+                    list(set_cdown.difference(set_gs_down)),
+                ]
+            )
 
     return (exc_up, exc_down)
 
 
-def get_unique_excitation(configs):
+def get_unique_excitation(
+    configs: Tuple[torch.LongTensor, torch.LongTensor]
+) -> Tuple[Tuple[List[List[int]], List[List[int]]], Tuple[List[int], List[int]]]:
     """get the unique excitation data
 
     Args:
         configs (tuple): configuratin of the electrons
 
     Returns:
-        exc_up, exc_down : index of the obitals in the excitaitons
-                            [i,j],[l,m] : excitation i -> l, j -> l
-        index_up, index_down : index map for the unique exc
-                                [0,0,...], [0,1,...] means that
-                                1st : excitation is composed of unique_up[0]*unique_down[0]
-                                2nd : excitation is composed of unique_up[0]*unique_down[1]
-                                ....
-
+        uniq_exc (tuple): unique excitation data
+            uniq_exc[0] (list): unique excitation of spin up
+            uniq_exc[1] (list): unique excitation of spin down
+        index_uniq_exc (tuple): index map for the unique exc
+            index_uniq_exc[0] (list): index of the unique excitation of spin up
+            index_uniq_exc[1] (list): index of the unique excitation of spin down
     """
     uniq_exc_up, uniq_exc_down = [], []
     index_uniq_exc_up, index_uniq_exc_down = [], []
     for ic, (cup, cdown) in enumerate(zip(configs[0], configs[1])):
-
         set_cup = set(tuple(cup.tolist()))
         set_cdown = set(tuple(cdown.tolist()))
 
@@ -338,11 +378,15 @@ def get_unique_excitation(configs):
             set_gs_up = set_cup
             set_gs_down = set_cdown
 
-        exc_up = [list(set_gs_up.difference(set_cup)),
-                  list(set_cup.difference(set_gs_up))]
+        exc_up = [
+            list(set_gs_up.difference(set_cup)),
+            list(set_cup.difference(set_gs_up)),
+        ]
 
-        exc_down = [list(set_gs_down.difference(set_cdown)),
-                    list(set_cdown.difference(set_gs_down))]
+        exc_down = [
+            list(set_gs_down.difference(set_cdown)),
+            list(set_cdown.difference(set_gs_down)),
+        ]
 
         if exc_up not in uniq_exc_up:
             uniq_exc_up.append(exc_up)
@@ -351,7 +395,6 @@ def get_unique_excitation(configs):
             uniq_exc_down.append(exc_down)
 
         index_uniq_exc_up.append(uniq_exc_up.index(exc_up))
-        index_uniq_exc_down.append(
-            uniq_exc_down.index(exc_down))
+        index_uniq_exc_down.append(uniq_exc_down.index(exc_down))
 
-    return (uniq_exc_up, uniq_exc_down), (index_uniq_exc_up, index_uniq_exc_down)
+    return ((uniq_exc_up, uniq_exc_down), (index_uniq_exc_up, index_uniq_exc_down))
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 5f1a3cae..40560859 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -1,13 +1,16 @@
 import torch
-
+from typing import List, Tuple
+from ...scf import Molecule
 
 class OrbitalProjector:
-
-    def __init__(self, configs, mol, cuda=False):
+    def __init__(self, 
+                 configs: List[torch.tensor], 
+                 mol: Molecule, 
+                 cuda: bool = False) -> None:
         """Project the MO matrix in Slater Matrices
 
         Args:
-            configs (list): configurations of the slater determinants
+            configs (List[torch.tensor]): configurations of the slater determinants
             mol (Molecule): Molecule object
             cuda (bool): use cuda or not
         """
@@ -17,60 +20,75 @@ def __init__(self, configs, mol, cuda=False):
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
-        self.device = torch.device('cpu')
+        
+        self.device = torch.device("cpu")
         if cuda:
-            self.device = torch.device('cuda')
-
-    def get_projectors(self):
-        """Get the projectors of the conf in the CI expansion
+            self.device = torch.device("cuda")
+        self.unique_configs, self.index_unique_configs = self.get_unique_configs()
+    def get_unique_configs(self) -> Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]:
+        """Get the unique configurations
 
         Returns:
-            torch.tensor, torch.tensor : projectors
+            Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]: 
+                configs_up (torch.Tensor): unique configurations of the spin up electrons
+                configs_down (torch.Tensor): unique configurations of the spin down electrons
+                index_unique_confs_up (torch.Tensor): index of the unique configurations of the spin up electrons
+                index_unique_confs_down (torch.Tensor): index of the unique configurations of the spin down electrons
         """
+        configs_up, index_unique_confs_up = torch.unique(self.configs[0], dim=0, return_inverse=True)
+        configs_down, index_unique_confs_down = torch.unique(self.configs[1], dim=0, return_inverse=True)
 
-        Pup = torch.zeros(self.nconfs, self.nmo, self.nup)
-        Pdown = torch.zeros(self.nconfs, self.nmo, self.ndown)
-
-        for ic, (cup, cdown) in enumerate(
-                zip(self.configs[0], self.configs[1])):
-
-            for _id, imo in enumerate(cup):
-                Pup[ic][imo, _id] = 1.
-
-            for _id, imo in enumerate(cdown):
-                Pdown[ic][imo, _id] = 1.
+        return (configs_up.to(self.device), configs_down.to(self.device)), (index_unique_confs_up.to(self.device), index_unique_confs_down.to(self.device))
 
-        return Pup.unsqueeze(1).to(self.device), Pdown.unsqueeze(1).to(self.device)
 
-    def split_orbitals(self, mat):
-        """Split the orbital  matrix in multiple slater matrices
+    def split_orbitals(
+        self,
+        mat: torch.Tensor,
+        unique_configs: bool = False
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Split the orbital matrix in multiple Slater matrices
+           This version does not store the projectors
 
         Args:
-            mat (torch.tensor): matrix to split
+            mat: matrix to split
+            unique_confgs: compute only the Slater matrices of the unique conf if True (Default=False)
 
         Returns:
-            torch.tensor: all slater matrices
+            Tuple[torch.Tensor, torch.Tensor]: all Slater matrices
         """
-        if not hasattr(self, 'Pup'):
-            self.Pup, self.Pdown = self.get_projectors()
+        if mat.ndim == 3:
+            nbatch = mat.shape[0]
+            out_up = torch.zeros(0, nbatch, self.nup, self.nup, device=self.device)
+            out_down = torch.zeros(0, nbatch, self.ndown, self.ndown, device=self.device)
 
         if mat.ndim == 4:
-            # case for multiple operators
-            out_up = mat[..., :self.nup, :] @ self.Pup.unsqueeze(1)
-            out_down = mat[..., self.nup:,
-                           :] @ self.Pdown.unsqueeze(1)
-
+            nbatch = mat.shape[1]
+            nop = mat.shape[0]
+            out_up = torch.zeros(0, nop, nbatch, self.nup, self.nup, device=self.device)
+            out_down = torch.zeros(0, nop, nbatch, self.ndown, self.ndown, device=self.device)
+        
+        if unique_configs :
+            configs_up, configs_down = self.unique_configs
+            
         else:
-            # case for single operator
-            out_up = mat[..., :self.nup, :] @ self.Pup
-            out_down = mat[..., self.nup:, :] @ self.Pdown
+            configs_up, configs_down = self.configs
+            
+        for _, (cup, cdown) in enumerate(zip(configs_up, configs_down)):
+        
+            # cat the tensors
+            out_up = torch.cat((out_up, mat[..., : self.nup, cup].unsqueeze(0)), dim=0)
+            out_down = torch.cat((out_down, mat[..., self.nup :, cdown].unsqueeze(0)), dim=0)
 
         return out_up, out_down
-
-
+        
 class ExcitationMask:
-
-    def __init__(self, unique_excitations, mol, max_orb, cuda=False):
+    def __init__(
+        self,
+        unique_excitations: List[Tuple[torch.Tensor, torch.Tensor]],
+        mol: Molecule,
+        max_orb: List[int],
+        cuda: bool = False,
+    ) -> None:
         """Select the occupied MOs of Slater determinant using masks
 
         Args:
@@ -88,16 +106,16 @@ def __init__(self, unique_excitations, mol, max_orb, cuda=False):
         self.nelec = mol.nelec
         self.max_orb = max_orb
 
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
-    def get_index_unique_single(self):
+    def get_index_unique_single(self) -> None:
         """Computes the 1D index and permutation
-           for the unique singles."""
+        for the unique singles."""
 
-        ncol_up = self.max_orb[0]-self.nup
-        ncol_down = self.max_orb[1]-self.ndown
+        ncol_up = self.max_orb[0] - self.nup
+        ncol_down = self.max_orb[1] - self.ndown
 
         self.index_unique_single_up = []
         self.index_unique_single_down = []
@@ -105,56 +123,54 @@ def get_index_unique_single(self):
         self.sign_unique_single_up = []
         self.sign_unique_single_down = []
 
-        for exc_up, exc_down in zip(self.unique_excitations[0],
-                                    self.unique_excitations[1]):
-
+        for exc_up, exc_down in zip(
+            self.unique_excitations[0], self.unique_excitations[1]
+        ):
             if len(exc_up[0]) == 1:
                 ielec, iorb = exc_up[0][0], exc_up[1][0]
-                icol = iorb-self.nup
+                icol = iorb - self.nup
 
-                self.index_unique_single_up.append(
-                    ielec*ncol_up + icol)
+                self.index_unique_single_up.append(ielec * ncol_up + icol)
 
-                npermut = self.nup-ielec-1
-                self.sign_unique_single_up.append((-1)**(npermut))
+                npermut = self.nup - ielec - 1
+                self.sign_unique_single_up.append((-1) ** (npermut))
 
             if len(exc_down[1]) == 1:
                 ielec, iorb = exc_down[0][0], exc_down[1][0]
-                icol = iorb-self.ndown
+                icol = iorb - self.ndown
 
-                self.index_unique_single_down.append(
-                    ielec*ncol_down + icol)
+                self.index_unique_single_down.append(ielec * ncol_down + icol)
 
-                npermut = self.ndown-ielec-1
-                self.sign_unique_single_down.append((-1)**(npermut))
+                npermut = self.ndown - ielec - 1
+                self.sign_unique_single_down.append((-1) ** (npermut))
 
-        self.sign_unique_single_up = torch.as_tensor(
-            self.sign_unique_single_up).to(self.device)
-        self.sign_unique_single_down = torch.as_tensor(
-            self.sign_unique_single_down).to(self.device)
+        self.sign_unique_single_up = torch.as_tensor(self.sign_unique_single_up).to(
+            self.device
+        )
+        self.sign_unique_single_down = torch.as_tensor(self.sign_unique_single_down).to(
+            self.device
+        )
 
-    def get_index_unique_double(self):
+    def get_index_unique_double(self) -> None:
         """Computes the 1D index of the double excitation matrices."""
 
-        ncol_up = self.max_orb[0]-self.nup
-        ncol_down = self.max_orb[1]-self.ndown
+        ncol_up = self.max_orb[0] - self.nup
+        ncol_down = self.max_orb[1] - self.ndown
 
         self.index_unique_double_up = []
         self.index_unique_double_down = []
 
-        for exc_up, exc_down in zip(self.unique_excitations[0],
-                                    self.unique_excitations[1]):
-
+        for exc_up, exc_down in zip(
+            self.unique_excitations[0], self.unique_excitations[1]
+        ):
             if len(exc_up[0]) == 2:
                 for ielec in exc_up[0]:
                     for iorb in exc_up[1]:
-                        icol = iorb-self.nup
-                        self.index_unique_double_up.append(
-                            ielec*ncol_up + icol)
+                        icol = iorb - self.nup
+                        self.index_unique_double_up.append(ielec * ncol_up + icol)
 
             if len(exc_down[1]) == 2:
                 for ielec in exc_up[0]:
                     for iorb in exc_up[1]:
-                        icol = iorb-self.ndown
-                        self.index_unique_double_down.append(
-                            ielec*ncol_down + icol)
+                        icol = iorb - self.ndown
+                        self.index_unique_double_down.append(ielec * ncol_down + icol)
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 1d380f1b..c5f1f1da 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -1,7 +1,9 @@
 import torch
 from torch import nn
 import operator as op
-
+from time import time
+from typing import Tuple, Callable, Optional, List, Union
+from ...scf import Molecule
 from ...utils import bdet2, btrace
 from .orbital_configurations import get_excitation, get_unique_excitation
 from .orbital_projector import ExcitationMask, OrbitalProjector
@@ -11,12 +13,19 @@ class SlaterPooling(nn.Module):
 
     """Applies a slater determinant pooling in the active space."""
 
-    def __init__(self, config_method, configs, mol, cuda=False):
-        """Computes the Sater determinants
+    def __init__(
+        self,
+        config_method: str,
+        configs: Tuple[torch.LongTensor, torch.LongTensor],
+        mol: Molecule,
+        cuda: bool = False,
+    ) -> None:
+        """Computes the Slater determinants
 
         Args:
             config_method (str): method used to define the config
-            configs (tuple): configuratin of the electrons
+            configs (Tuple[torch.LongTensor, torch.LongTensor]):
+                configuratin of the electrons
             mol (Molecule): Molecule instance
             cuda (bool, optional): Turns GPU ON/OFF. Defaults to False.
 
@@ -32,50 +41,60 @@ def __init__(self, config_method, configs, mol, cuda=False):
 
         self.excitation_index = get_excitation(configs)
         self.unique_excitation, self.index_unique_excitation = get_unique_excitation(
-            configs)
+            configs
+        )
 
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
         self.nelec = self.nup + self.ndown
+        self.use_explicit_operator = False
 
         self.orb_proj = OrbitalProjector(configs, mol, cuda=cuda)
-        self.exc_mask = ExcitationMask(self.unique_excitation, mol,
-                                       (self.index_max_orb_up,
-                                        self.index_max_orb_down),
-                                       cuda=cuda)
-
-        self.device = torch.device('cpu')
+        self.exc_mask = ExcitationMask(
+            self.unique_excitation,
+            mol,
+            (self.index_max_orb_up, self.index_max_orb_down),
+            cuda=cuda,
+        )
+
+        self.device = torch.device("cpu")
         if cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
 
-    def forward(self, input):
+    def forward(self, input: torch.Tensor) -> torch.Tensor:
         """Computes the values of the determinats
 
         Args:
-            input (torch.tensor): MO matrices nbatch x nelec x nmo
+            input (torch.Tensor): MO matrices nbatch x nelec x nmo
 
         Returns:
-            torch.tensor: slater determinants
+            torch.Tensor: slater determinants
         """
-        if self.config_method.startswith('cas('):
+        if self.config_method.startswith("cas("):
+            return self.det_explicit(input)
+        elif self.config_method == 'explicit':
             return self.det_explicit(input)
         else:
+            if self.use_explicit_operator:
+                return self.det_explicit(input)
             return self.det_single_double(input)
 
-    def get_slater_matrices(self, input):
+    def get_slater_matrices(
+        self, input: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the slater matrices
 
         Args:
-            input (torch.tensor): MO matrices nbatch x nelec x nmo
-
+            input (torch.Tensor): MO matrices nbatch x nelec x nmo
 
         Returns:
-            (torch.tensor, torch.tensor): slater matrices of spin up/down
+            Tuple[torch.Tensor, torch.Tensor]:
+                slater matrices of spin up/down
         """
-        return self.orb_proj.split_orbitals(input)
+        return self.orb_proj.split_orbitals(input, unique_configs=True)
 
-    def det_explicit(self, input):
+    def det_explicit(self, input: torch.Tensor) -> torch.Tensor:
         """Computes the values of the determinants from the slater matrices
 
         Args:
@@ -84,39 +103,44 @@ def det_explicit(self, input):
         Returns:
             torch.tensor: slater determinants
         """
-
         mo_up, mo_down = self.get_slater_matrices(input)
-        return (torch.det(mo_up) * torch.det(mo_down)).transpose(0, 1)
+        det_up = torch.det(mo_up)
+        det_down = torch.det(mo_down) 
+        return (det_up[self.orb_proj.index_unique_configs[0], ...] * det_down[self.orb_proj.index_unique_configs[1], ...]).transpose(0, 1)
 
-    def det_single_double(self, input):
-        """Computes the determinant of ground state + single + double
+    def det_single_double(self, input: torch.Tensor) -> torch.Tensor:
+        """Computes the determinant of ground state + single + double excitations.
 
         Args:
-            input (torch.tensor): MO matrices nbatch x nelec x nmo
+            input (torch.Tensor): MO matrices nbatch x nelec x nmo
 
         Returns:
-            torch.tensor: slater determinants
+            torch.Tensor: Slater determinants for the configurations
         """
+        # Compute the determinant of the unique single and double excitations
+        det_unique_up, det_unique_down = self.det_unique_single_double(input)
 
-        # compute the determinant of the unique single excitation
-        det_unique_up, det_unique_down = self.det_unique_single_double(
-            input)
+        # Returns the product of spin up/down determinants required by each excitation
+        return (
+            det_unique_up[:, self.index_unique_excitation[0]]
+            * det_unique_down[:, self.index_unique_excitation[1]]
+        )
 
-        # returns the product of spin up/down required by each excitation
-        return (det_unique_up[:, self.index_unique_excitation[0]] *
-                det_unique_down[:, self.index_unique_excitation[1]])
-
-    def det_ground_state(self, input):
-        """Computes the SD of the ground state
+    def det_ground_state(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Computes the Slater determinants of the ground state.
 
         Args:
-            input (torch.tensor): MO matrices nbatch x nelec x nmo
-        """
+            input (torch.Tensor): Molecular orbital matrices of shape (nbatch, nelec, nmo).
 
-        return (torch.det(input[:, :self.nup, :self.nup]),
-                torch.det(input[:, self.nup:, :self.ndown]))
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: Slater determinants for spin up and spin down configurations.
+        """
+        return (
+            torch.det(input[:, : self.nup, : self.nup]),
+            torch.det(input[:, self.nup :, : self.ndown]),
+        )
 
-    def det_unique_single_double(self, input):
+    def det_unique_single_double(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the SD of single/double excitations
 
         The determinants of the single excitations
@@ -126,7 +150,7 @@ def det_unique_single_double(self, input):
         B.L. Hammond, appendix B1
 
 
-        Note : if the state on coonfigs are specified in order
+        Note : if the state on configs are specified in order
         we end up with excitations that comes from a deep orbital, the resulting
         slater matrix has one column changed (with the new orbital) and several
         permutation. We therefore need to multiply the slater determinant
@@ -145,21 +169,21 @@ def det_unique_single_double(self, input):
 
         nbatch = input.shape[0]
 
-        if not hasattr(self.exc_mask, 'index_unique_single_up'):
+        if not hasattr(self.exc_mask, "index_unique_single_up"):
             self.exc_mask.get_index_unique_single()
 
-        if not hasattr(self.exc_mask, 'index_unique_double_up'):
+        if not hasattr(self.exc_mask, "index_unique_double_up"):
             self.exc_mask.get_index_unique_double()
 
         do_single = len(self.exc_mask.index_unique_single_up) != 0
         do_double = len(self.exc_mask.index_unique_double_up) != 0
 
         # occupied orbital matrix + det and inv on spin up
-        Aup = input[:, :self.nup, :self.nup]
+        Aup = input[:, : self.nup, : self.nup]
         detAup = torch.det(Aup)
 
         # occupied orbital matrix + det and inv on spin down
-        Adown = input[:, self.nup:, :self.ndown]
+        Adown = input[:, self.nup :, : self.ndown]
         detAdown = torch.det(Adown)
 
         # store all the dets we need
@@ -167,7 +191,7 @@ def det_unique_single_double(self, input):
         det_out_down = detAdown.unsqueeze(-1).clone()
 
         # return the ground state
-        if self.config_method == 'ground_state':
+        if self.config_method == "ground_state":
             return det_out_up, det_out_down
 
         # inverse of the
@@ -175,91 +199,100 @@ def det_unique_single_double(self, input):
         invAdown = torch.inverse(Adown)
 
         # virtual orbital matrices spin up/down
-        Bup = input[:, :self.nup, self.nup:self.index_max_orb_up]
-        Bdown = input[:, self.nup:,
-                      self.ndown: self.index_max_orb_down]
+        Bup = input[:, : self.nup, self.nup : self.index_max_orb_up]
+        Bdown = input[:, self.nup :, self.ndown : self.index_max_orb_down]
 
         # compute the products of Ain and B
-        mat_exc_up = (invAup @ Bup)
-        mat_exc_down = (invAdown @ Bdown)
+        mat_exc_up = invAup @ Bup
+        mat_exc_down = invAdown @ Bdown
 
         if do_single:
-
             # determinant of the unique excitation spin up
-            det_single_up = mat_exc_up.view(
-                nbatch, -1)[:, self.exc_mask.index_unique_single_up]
+            det_single_up = mat_exc_up.view(nbatch, -1)[
+                :, self.exc_mask.index_unique_single_up
+            ]
 
             # determinant of the unique excitation spin down
-            det_single_down = mat_exc_down.view(
-                nbatch, -1)[:, self.exc_mask.index_unique_single_down]
+            det_single_down = mat_exc_down.view(nbatch, -1)[
+                :, self.exc_mask.index_unique_single_down
+            ]
 
             # multiply with ground state determinant
             # and account for permutation for deep excitation
-            det_single_up = detAup.unsqueeze(-1) * \
-                det_single_up.view(nbatch, -1)
+            det_single_up = detAup.unsqueeze(-1) * det_single_up.view(nbatch, -1)
 
             # multiply with ground state determinant
             # and account for permutation for deep excitation
-            det_single_down = detAdown.unsqueeze(-1) * \
-                det_single_down.view(nbatch, -1)
+            det_single_down = detAdown.unsqueeze(-1) * det_single_down.view(nbatch, -1)
 
             # accumulate the dets
             det_out_up = torch.cat((det_out_up, det_single_up), dim=1)
-            det_out_down = torch.cat(
-                (det_out_down, det_single_down), dim=1)
+            det_out_down = torch.cat((det_out_down, det_single_down), dim=1)
 
         if do_double:
-
             # det of unique spin up double exc
-            det_double_up = mat_exc_up.view(
-                nbatch, -1)[:, self.exc_mask.index_unique_double_up]
+            det_double_up = mat_exc_up.view(nbatch, -1)[
+                :, self.exc_mask.index_unique_double_up
+            ]
 
-            det_double_up = bdet2(
-                det_double_up.view(nbatch, -1, 2, 2))
+            det_double_up = bdet2(det_double_up.view(nbatch, -1, 2, 2))
 
             det_double_up = detAup.unsqueeze(-1) * det_double_up
 
             # det of unique spin down double exc
-            det_double_down = mat_exc_down.view(
-                nbatch, -1)[:, self.exc_mask.index_unique_double_down]
+            det_double_down = mat_exc_down.view(nbatch, -1)[
+                :, self.exc_mask.index_unique_double_down
+            ]
 
-            det_double_down = bdet2(
-                det_double_down.view(nbatch, -1, 2, 2))
+            det_double_down = bdet2(det_double_down.view(nbatch, -1, 2, 2))
 
             det_double_down = detAdown.unsqueeze(-1) * det_double_down
 
             det_out_up = torch.cat((det_out_up, det_double_up), dim=1)
-            det_out_down = torch.cat(
-                (det_out_down, det_double_down), dim=1)
+            det_out_down = torch.cat((det_out_down, det_double_down), dim=1)
 
         return det_out_up, det_out_down
 
-    def operator(self, mo, bop, op=op.add, op_squared=False):
+    def operator(
+        self,
+        mo: torch.Tensor,
+        bop: torch.Tensor,
+        op: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] = op.add,
+        op_squared: bool = False,
+        inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    ) -> torch.Tensor:
         """Computes the values of an opearator applied to the procuts of determinant
 
         Args:
-            mo (torch.tensor): matrix of MO vals(Nbatch, Nelec, Nmo)
-            bkin (torch.tensor): kinetic operator (Nbatch, Nelec, Nmo)
+            mo (torch.Tensor): matrix of MO vals(Nbatch, Nelec, Nmo)
+            bkin (torch.Tensor): kinetic operator (Nbatch, Nelec, Nmo)
             op (operator): how to combine the up/down contribution
-            op_squared (bool, optional) return the trace of the square of the product if True
+            op_squared (bool, optional): return the trace of the square of the product if True
+            inv_mo (tupe, optional): precomputed inverse of the mo up & down matrices
 
         Returns:
-            torch.tensor: kinetic energy
+            torch.Tensor: kinetic energy
         """
 
         # get the values of the operator
-        if self.config_method == 'ground_state':
+        if self.config_method == "ground_state":
             op_vals = self.operator_ground_state(mo, bop, op_squared)
 
-        elif self.config_method.startswith('single'):
-            op_vals = self.operator_single_double(mo, bop, op_squared)
 
-        elif self.config_method.startswith('cas('):
+        elif self.config_method.startswith("single"):
+            if self.use_explicit_operator:
+                op_vals = self.operator_explicit(mo, bop, op_squared)
+            else:
+                op_vals = self.operator_single_double(mo, bop, op_squared, inv_mo)
+
+        elif self.config_method.startswith("cas("):
+            op_vals = self.operator_explicit(mo, bop, op_squared)
+
+        elif self.config_method == 'explicit':
             op_vals = self.operator_explicit(mo, bop, op_squared)
 
         else:
-            raise ValueError(
-                'Configuration %s not recognized' % self.config_method)
+            raise ValueError("Configuration %s not recognized" % self.config_method)
 
         # combine the values is necessary
         if op is not None:
@@ -267,31 +300,32 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
         else:
             return op_vals
 
-    def operator_ground_state(self, mo, bop, op_squared=False):
+    def operator_ground_state(
+            self, 
+            mo: torch.Tensor, 
+            bop: torch.Tensor, 
+            op_squared: bool = False, 
+            inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the values of any operator on gs only
 
         Args:
             mo (torch.tensor): matrix of molecular orbitals
-            bkin (torch.tensor): matrix of kinetic operator
+            bop (torch.tensor): matrix of kinetic operator
             op_squared (bool, optional) return the trace of the square of the product if True
+            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
 
         Returns:
-            torch.tensor: operator values
+            tuple: operator values
         """
-
-        # occupied orbital matrix + det and inv on spin up
-        Aocc_up = mo[:, :self.nup, :self.nup]
-
-        # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
-
-        # inverse of the
-        invAup = torch.inverse(Aocc_up)
-        invAdown = torch.inverse(Aocc_down)
+        if inv_mo is None:
+            invAup, invAdown = self.compute_inverse_occupied_mo_matrix(mo)
+        else:
+            invAup, invAdown = inv_mo
 
         # precompute the product A^{-1} B
-        op_ground_up = invAup @ bop[..., :self.nup, :self.nup]
-        op_ground_down = invAdown @ bop[..., self.nup:, :self.ndown]
+        op_ground_up = invAup @ bop[..., : self.nup, : self.nup]
+        op_ground_down = invAdown @ bop[..., self.nup :, : self.ndown]
 
         if op_squared:
             op_ground_up = op_ground_up @ op_ground_up
@@ -306,7 +340,12 @@ def operator_ground_state(self, mo, bop, op_squared=False):
 
         return op_ground_up, op_ground_down
 
-    def operator_explicit(self, mo, bkin, op_squared=False):
+    def operator_explicit(
+        self,
+        mo: torch.Tensor,
+        bkin: torch.Tensor,
+        op_squared: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         r"""Computes the value of any operator using the trace trick for a product
             of spin up/down determinant.
 
@@ -315,20 +354,20 @@ def operator_explicit(self, mo, bkin, op_squared=False):
             ( \Delta_{up} D_{up} / D_{up} + \Delta_{down} D_{down}  / D_{down} )
 
         Args:
-            mo (torch.tensor): matrix of MO vals(Nbatch, Nelec, Nmo)
-            bkin (torch.tensor): kinetic operator (Nbatch, Nelec, Nmo)
-            op_squared (bool, optional) return the trace of the square of the product if True
+            mo: matrix of MO vals(Nbatch, Nelec, Nmo)
+            bkin: kinetic operator (Nbatch, Nelec, Nmo)
+            op_squared: return the trace of the square of the product if True
 
         Returns:
-            torch.tensor: kinetic energy
+            tuple: kinetic energy
         """
 
         # shortcut up/down matrices
-        Aup, Adown = self.orb_proj.split_orbitals(mo)
-        Bup, Bdown = self.orb_proj.split_orbitals(bkin)
+        Aup, Adown = self.orb_proj.split_orbitals(mo, unique_configs=True)
+        Bup, Bdown = self.orb_proj.split_orbitals(bkin, unique_configs=True)
 
-        # check ifwe have 1 or multiple ops
-        multiple_op = (Bup.ndim == 5)
+        # check if we have 1 or multiple ops
+        multiple_op = Bup.ndim == 5
 
         # inverse of MO matrices
         iAup = torch.inverse(Aup)
@@ -359,64 +398,82 @@ def operator_explicit(self, mo, bkin, op_squared=False):
             op_val_up = op_val_up.transpose(0, 1)
             op_val_down = op_val_down.transpose(0, 1)
 
-        return (op_val_up, op_val_down)
-
-    def operator_single_double(self, mo, bop, op_squared=False):
+        return (
+            op_val_up[..., self.orb_proj.index_unique_configs[0]],
+            op_val_down[..., self.orb_proj.index_unique_configs[1]],
+        )
+
+    def operator_single_double(
+        self,
+        mo: torch.Tensor,
+        bop: torch.Tensor,
+        op_squared: bool = False,
+        inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the value of any operator on gs + single + double
 
         Args:
-            mo (torch.tensor): matrix of molecular orbitals
-            bkin (torch.tensor): matrix of kinetic operator
-            op_squared (bool, optional) return the trace of the square of the product if True
+            mo: matrix of molecular orbitals (torch.tensor)
+            bop: matrix of kinetic operator (torch.tensor)
+            op_squared: return the trace of the square of the product if True (bool)
+            inv_mo: precomputed inverse of the up/down MO matrices (tuple, optional)
 
         Returns:
-            torch.tensor: kinetic energy values
+            tuple: kinetic energy values (torch.tensor)
         """
 
-        op_up, op_down = self.operator_unique_single_double(
-            mo, bop, op_squared)
+        op_up, op_down = self.operator_unique_single_double(mo, bop, op_squared, inv_mo)
 
-        return (op_up[..., self.index_unique_excitation[0]],
-                op_down[..., self.index_unique_excitation[1]])
+        return (
+            op_up[..., self.index_unique_excitation[0]],
+            op_down[..., self.index_unique_excitation[1]],
+        )
 
-    def operator_unique_single_double(self, mo, bop, op_squared):
+    def operator_unique_single_double(
+            self, 
+            mo: torch.Tensor, 
+            bop: torch.Tensor, 
+            op_squared: bool, 
+            inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Compute the operator value of the unique single/double conformation
 
         Args:
-            mo ([type]): [description]
-            bkin ([type]): [description]
-            op_squared (bool) return the trace of the square of the product
+            mo (torch.Tensor): matrix of molecular orbitals
+            bop (torch.Tensor): matrix of kinetic operator
+            op_squared (bool): return the trace of the square of the product if True
+            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
+
+        Returns:
+            tuple: operator values
         """
 
         nbatch = mo.shape[0]
 
-        if not hasattr(self.exc_mask, 'index_unique_single_up'):
+        if not hasattr(self.exc_mask, "index_unique_single_up"):
             self.exc_mask.get_index_unique_single()
 
-        if not hasattr(self.exc_mask, 'index_unique_double_up'):
+        if not hasattr(self.exc_mask, "index_unique_double_up"):
             self.exc_mask.get_index_unique_double()
 
         do_single = len(self.exc_mask.index_unique_single_up) != 0
         do_double = len(self.exc_mask.index_unique_double_up) != 0
 
-        # occupied orbital matrix + det and inv on spin up
-        Aocc_up = mo[:, :self.nup, :self.nup]
-
-        # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
-
-        # inverse of the
-        invAup = torch.inverse(Aocc_up)
-        invAdown = torch.inverse(Aocc_down)
+        # compute or retrieve the inverse of the up/down MO matrices 
+        if inv_mo is None:
+            invAup, invAdown = self.compute_inverse_occupied_mo_matrix(mo)
+        else:
+            invAup, invAdown = inv_mo
+        
 
         # precompute invA @ B
-        invAB_up = invAup @ bop[..., :self.nup, :self.nup]
-        invAB_down = invAdown @ bop[..., self.nup:, :self.ndown]
+        invAB_up = invAup @ bop[..., : self.nup, : self.nup]
+        invAB_down = invAdown @ bop[..., self.nup :, : self.ndown]
 
         # ground state operator
         if op_squared:
-            op_ground_up = btrace(invAB_up@invAB_up)
-            op_ground_down = btrace(invAB_down@invAB_down)
+            op_ground_up = btrace(invAB_up @ invAB_up)
+            op_ground_down = btrace(invAB_down @ invAB_down)
         else:
             op_ground_up = btrace(invAB_up)
             op_ground_down = btrace(invAB_down)
@@ -429,28 +486,27 @@ def operator_unique_single_double(self, mo, bop, op_squared):
         op_out_down = op_ground_down.clone()
 
         # virtual orbital matrices spin up/down
-        Avirt_up = mo[:, :self.nup, self.nup:self.index_max_orb_up]
-        Avirt_down = mo[:, self.nup:,
-                        self.ndown: self.index_max_orb_down]
+        Avirt_up = mo[:, : self.nup, self.nup : self.index_max_orb_up]
+        Avirt_down = mo[:, self.nup :, self.ndown : self.index_max_orb_down]
 
         # compute the products of invA and Btilde
-        mat_exc_up = (invAup @ Avirt_up)
-        mat_exc_down = (invAdown @ Avirt_down)
+        mat_exc_up = invAup @ Avirt_up
+        mat_exc_down = invAdown @ Avirt_down
 
-        bop_up = bop[..., :self.nup, :self.index_max_orb_up]
-        bop_occ_up = bop[..., :self.nup, :self.nup]
-        bop_virt_up = bop[..., :self.nup,
-                          self.nup:self.index_max_orb_up]
+        # bop_up = bop[..., :self.nup, :self.index_max_orb_up]
+        bop_occ_up = bop[..., : self.nup, : self.nup]
+        bop_virt_up = bop[..., : self.nup, self.nup : self.index_max_orb_up]
 
-        bop_down = bop[:, self.nup:, :self.index_max_orb_down]
-        bop_occ_down = bop[..., self.nup:, :self.ndown]
-        bop_virt_down = bop[..., self.nup:,
-                            self.ndown:self.index_max_orb_down]
+        # bop_down = bop[:, self.nup:, :self.index_max_orb_down]
+        bop_occ_down = bop[..., self.nup :, : self.ndown]
+        bop_virt_down = bop[..., self.nup :, self.ndown : self.index_max_orb_down]
 
         Mup = invAup @ bop_virt_up - invAup @ bop_occ_up @ invAup @ Avirt_up
-        Mdown = invAdown @ bop_virt_down - \
-            invAdown @ bop_occ_down @ invAdown @ Avirt_down
+        Mdown = (
+            invAdown @ bop_virt_down - invAdown @ bop_occ_down @ invAdown @ Avirt_down
+        )
 
+        
         # if we only want the normal value of the op and not its squared
         if not op_squared:
 
@@ -459,40 +515,56 @@ def operator_unique_single_double(self, mo, bop, op_squared):
             Mdown = Mdown.view(*Mdown.shape[:-2], -1)
 
             if do_single:
-
                 # spin up
-                op_sin_up = self.op_single(op_ground_up, mat_exc_up, Mup,
-                                           self.exc_mask.index_unique_single_up, nbatch)
+                op_sin_up = self.op_single(
+                    op_ground_up,
+                    mat_exc_up,
+                    Mup,
+                    self.exc_mask.index_unique_single_up,
+                    nbatch,
+                )
 
                 # spin down
-                op_sin_down = self.op_single(op_ground_down, mat_exc_down, Mdown,
-                                             self.exc_mask.index_unique_single_down, nbatch)
+                op_sin_down = self.op_single(
+                    op_ground_down,
+                    mat_exc_down,
+                    Mdown,
+                    self.exc_mask.index_unique_single_down,
+                    nbatch,
+                )
 
                 # store the terms we need
                 op_out_up = torch.cat((op_out_up, op_sin_up), dim=-1)
-                op_out_down = torch.cat(
-                    (op_out_down, op_sin_down), dim=-1)
+                op_out_down = torch.cat((op_out_down, op_sin_down), dim=-1)
 
             if do_double:
-
                 # spin up
-                op_dbl_up = self.op_multiexcitation(op_ground_up, mat_exc_up, Mup,
-                                                    self.exc_mask.index_unique_double_up,
-                                                    2, nbatch)
+                op_dbl_up = self.op_multiexcitation(
+                    op_ground_up,
+                    mat_exc_up,
+                    Mup,
+                    self.exc_mask.index_unique_double_up,
+                    2,
+                    nbatch,
+                )
 
                 # spin down
-                op_dbl_down = self.op_multiexcitation(op_ground_down, mat_exc_down, Mdown,
-                                                      self.exc_mask.index_unique_double_down,
-                                                      2, nbatch)
+                op_dbl_down = self.op_multiexcitation(
+                    op_ground_down,
+                    mat_exc_down,
+                    Mdown,
+                    self.exc_mask.index_unique_double_down,
+                    2,
+                    nbatch,
+                )
 
                 # store the terms we need
                 op_out_up = torch.cat((op_out_up, op_dbl_up), dim=-1)
-                op_out_down = torch.cat(
-                    (op_out_down, op_dbl_down), dim=-1)
+                op_out_down = torch.cat((op_out_down, op_dbl_down), dim=-1)
 
             return op_out_up, op_out_down
 
-        # if we watn the squre of the operatore
+        # if we want the squre of the operator
         # typically trace(ABAB)
         else:
 
@@ -509,47 +581,68 @@ def operator_unique_single_double(self, mo, bop, op_squared):
             Ydown = Ydown.view(*Ydown.shape[:-2], -1)
 
             if do_single:
-
                 # spin up
-                op_sin_up = self.op_squared_single(op_ground_up, mat_exc_up,
-                                                   Mup, Yup,
-                                                   self.exc_mask.index_unique_single_up,
-                                                   nbatch)
+                op_sin_up = self.op_squared_single(
+                    op_ground_up,
+                    mat_exc_up,
+                    Mup,
+                    Yup,
+                    self.exc_mask.index_unique_single_up,
+                    nbatch,
+                )
 
                 # spin down
-                op_sin_down = self.op_squared_single(op_ground_down, mat_exc_down,
-                                                     Mdown, Ydown,
-                                                     self.exc_mask.index_unique_single_down,
-                                                     nbatch)
+                op_sin_down = self.op_squared_single(
+                    op_ground_down,
+                    mat_exc_down,
+                    Mdown,
+                    Ydown,
+                    self.exc_mask.index_unique_single_down,
+                    nbatch,
+                )
 
                 # store the terms we need
                 op_out_up = torch.cat((op_out_up, op_sin_up), dim=-1)
-                op_out_down = torch.cat(
-                    (op_out_down, op_sin_down), dim=-1)
+                op_out_down = torch.cat((op_out_down, op_sin_down), dim=-1)
 
             if do_double:
-
+                
                 # spin up values
-                op_dbl_up = self.op_squared_multiexcitation(op_ground_up, mat_exc_up,
-                                                            Mup, Yup,
-                                                            self.exc_mask.index_unique_double_down,
-                                                            2, nbatch)
+                op_dbl_up = self.op_squared_multiexcitation(
+                    op_ground_up,
+                    mat_exc_up,
+                    Mup,
+                    Yup,
+                    self.exc_mask.index_unique_double_down,
+                    2,
+                    nbatch,
+                )
 
                 # spin down values
-                op_dbl_down = self.op_squared_multiexcitation(op_ground_down, mat_exc_down,
-                                                              Mdown, Ydown,
-                                                              self.exc_mask.index_unique_double_down,
-                                                              2, nbatch)
+                op_dbl_down = self.op_squared_multiexcitation(
+                    op_ground_down,
+                    mat_exc_down,
+                    Mdown,
+                    Ydown,
+                    self.exc_mask.index_unique_double_down,
+                    2,
+                    nbatch,
+                )
 
                 # store the terms we need
                 op_out_up = torch.cat((op_out_up, op_dbl_up), dim=-1)
-                op_out_down = torch.cat(
-                    (op_out_down, op_dbl_down), dim=-1)
+                op_out_down = torch.cat((op_out_down, op_dbl_down), dim=-1)
 
             return op_out_up, op_out_down
 
     @staticmethod
-    def op_single(baseterm, mat_exc, M, index, nbatch):
+    def op_single(
+        baseterm: torch.Tensor,
+        mat_exc: torch.Tensor,
+        M: torch.Tensor,
+        index: List[int],
+        nbatch: int,
+    ) -> torch.Tensor:
         r"""Computes the operator values for single excitation
 
         .. math::
@@ -558,15 +651,18 @@ def op_single(baseterm, mat_exc, M, index, nbatch):
             M = A^{-1}\bar{B} - A^{-1}BA^{-1}\bar{A}
 
         Args:
-            baseterm (torch.tensor): trace(A B)
-            mat_exc (torch.tensor): invA @ Abar
-            M (torch.tensor): invA Bbar - inv A B inv A Abar
-            index(List): list of index of the excitations
-            nbatch : batch size
+            baseterm (torch.Tensor): trace(A B)
+            mat_exc (torch.Tensor): invA @ Abar
+            M (torch.Tensor): invA Bbar - inv A B inv A Abar
+            index (List[int]): list of index of the excitations
+            nbatch (int): batch size
+
+        Returns:
+            torch.Tensor: trace(T M) + trace(A B)
         """
 
         # compute the values of T
-        T = (1. / mat_exc.view(nbatch, -1)[:, index])
+        T = 1.0 / mat_exc.view(nbatch, -1)[:, index]
 
         # computes trace(T M)
         op_vals = T * M[..., index]
@@ -577,7 +673,14 @@ def op_single(baseterm, mat_exc, M, index, nbatch):
         return op_vals
 
     @staticmethod
-    def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
+    def op_multiexcitation(
+        baseterm: torch.Tensor, 
+        mat_exc: torch.Tensor, 
+        M: torch.Tensor,
+        index: List[int], 
+        size: int, 
+        nbatch: int
+    ) -> torch.Tensor:
         r"""Computes the operator values for single excitation
 
         .. math::
@@ -586,12 +689,14 @@ def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
             M = A^{-1}\bar{B} - A^{-1}BA^{-1}\bar{A}
 
         Args:
-            baseterm (torch.tensor): trace(A B)
-            mat_exc (torch.tensor): invA @ Abar
-            M (torch.tensor): invA Bbar - inv A B inv A Abar
-            index(List): list of index of the excitations
-            size(int) : number of excitation
-            nbatch : batch size
+            baseterm (torch.Tensor): trace(A B)
+            mat_exc (torch.Tensor): invA @ Abar
+            M (torch.Tensor): invA Bbar - inv A B inv A Abar
+            index (List[int]): list of index of the excitations
+            size (int): number of excitation
+            nbatch (int): batch size
+        Returns:
+            torch.Tensor: trace(A B) + trace(T M)
         """
 
         # get the values of the excitation matrix invA Abar
@@ -605,7 +710,9 @@ def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
         T = torch.inverse(T.view(_ext_shape))
 
         # computes T @ M (after reshaping M as size x size matrices)
-        op_vals = T @ (M[..., index]).view(_m_shape)
+        # THIS IS SURPRSINGLY THE COMPUTATIONAL BOTTLENECK
+        m_tmp = M[..., index].view(_m_shape)
+        op_vals =  T @ m_tmp
 
         # compute the trace
         op_vals = btrace(op_vals)
@@ -616,7 +723,14 @@ def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
         return op_vals
 
     @staticmethod
-    def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
+    def op_squared_single(
+        baseterm: torch.Tensor,
+        mat_exc: torch.Tensor,
+        M: torch.Tensor,
+        Y: torch.Tensor,
+        index: List[int],
+        nbatch: int
+    ) -> torch.Tensor:
         r"""Computes the operator squared for single excitation
 
         .. math::
@@ -626,23 +740,25 @@ def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
             Y = A^{-1} B M
 
         Args:
-            baseterm (torch.tensor): trace(A B A B)
-            mat_exc (torch.tensor): invA @ Abar
-            M (torch.tensor): invA Bbar - inv A B inv A Abar
-            Y (torch.tensor): invA B M
-            index(List): list of index of the excitations
-            nbatch : batch size
+            baseterm (torch.Tensor): trace(A B A B)
+            mat_exc (torch.Tensor): invA @ Abar
+            M (torch.Tensor): invA Bbar - inv A B inv A Abar
+            Y (torch.Tensor): invA B M
+            index (List[int]): list of index of the excitations
+            nbatch (int): batch size
+        Returns:
+            torch.Tensor: trace((A^{-1} B)^2) + trace((T M)^2) + 2 trace(T Y)
         """
 
         # get the values of the inverse excitation matrix
-        T = 1. / (mat_exc.view(nbatch, -1)[:, index])
+        T = 1.0 / (mat_exc.view(nbatch, -1)[:, index])
 
         # compute  trace(( T M )^2)
-        tmp = (T * M[..., index])
-        op_vals = tmp*tmp
+        tmp = T * M[..., index]
+        op_vals = tmp * tmp
 
         # trace(T Y)
-        tmp = (T * Y[..., index])
+        tmp = T * Y[..., index]
         op_vals += 2 * tmp
 
         # add the base term
@@ -651,7 +767,15 @@ def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
         return op_vals
 
     @staticmethod
-    def op_squared_multiexcitation(baseterm, mat_exc, M, Y, index, size, nbatch):
+    def op_squared_multiexcitation(
+        baseterm: torch.tensor,
+        mat_exc: torch.tensor,
+        M: torch.tensor,
+        Y: torch.tensor,
+        index: List[int],
+        size: int,
+        nbatch: int
+    ) -> torch.tensor:
         r"""Computes the operator squared for multiple excitation
 
         .. math::
@@ -665,9 +789,11 @@ def op_squared_multiexcitation(baseterm, mat_exc, M, Y, index, size, nbatch):
             mat_exc (torch.tensor): invA @ Abar
             M (torch.tensor): invA Bbar - inv A B inv A Abar
             Y (torch.tensor): invA B M
-            index(List): list of index of the excitations
-            nbatch : batch size
-            size(int): number of excitation
+            index (List[int]): list of index of the excitations
+            nbatch (int): batch size
+            size (int): number of excitation
+        Returns:
+            torch.tensor: trace((A^{-1} B)^2) + trace((T M)^2) + 2 trace(T Y)
         """
 
         # get the values of the excitation matrix invA Abar
@@ -691,9 +817,33 @@ def op_squared_multiexcitation(baseterm, mat_exc, M, Y, index, size, nbatch):
         # compute trace( T Y )
         tmp = T @ (Y[..., index]).view(_y_shape)
         tmp = btrace(tmp)
-        op_vals += 2*tmp
+        op_vals += 2 * tmp
 
         # add the base term
         op_vals += baseterm
 
         return op_vals
+    
+
+    def compute_inverse_occupied_mo_matrix( 
+            self, 
+            mo: torch.Tensor
+            ) -> Union[Tuple[torch.Tensor, torch.Tensor], None]:
+        """precompute the inverse of the occupied mo matrix
+
+        Args:
+            mo (torch.tensor): matrix of the molecular orbitals
+
+        Returns:
+            tuple: inverse of the spin up/down mo matrices
+        """
+        # return None if we use the explicit calculation of all dets
+        if self.config_method.startswith("cas("):
+            return None 
+        
+        if self.use_explicit_operator:
+            return None
+        
+        # return inverse of the mo matrices
+        return (torch.inverse(mo[:, : self.nup, : self.nup]), 
+                torch.inverse(mo[:, self.nup :, : self.ndown]))
diff --git a/qmctorch/wavefunction/slater_combined_jastrow.py b/qmctorch/wavefunction/slater_combined_jastrow.py
deleted file mode 100644
index b308d190..00000000
--- a/qmctorch/wavefunction/slater_combined_jastrow.py
+++ /dev/null
@@ -1,86 +0,0 @@
-
-
-import numpy as np
-import torch
-from .slater_jastrow import SlaterJastrow
-
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecElec
-from .jastrows.jastrow_factor_combined_terms import JastrowFactorCombinedTerms
-from .jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecNuc
-
-
-class SlaterManyBodyJastrow(SlaterJastrow):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel={
-                     'ee': PadeJastrowKernelElecElec,
-                     'en': PadeJastrowKernelElecNuc,
-                     'een': None},
-                 jastrow_kernel_kwargs={
-                     'ee': {},
-                     'en': {},
-                     'een': {}},
-                 cuda=False,
-                 include_all_mo=True):
-        """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 (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 (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 = SlaterManyBodyJastrow(mol, configs='cas(2,2)')
-        """
-
-        super().__init__(mol, configs, kinetic, None, {}, cuda, include_all_mo)
-
-        # process the Jastrow
-        if jastrow_kernel is not None:
-
-            for k in ['ee', 'en', 'een']:
-                if k not in jastrow_kernel.keys():
-                    jastrow_kernel[k] = None
-                if k not in jastrow_kernel_kwargs.keys():
-                    jastrow_kernel_kwargs[k] = None
-
-            self.use_jastrow = True
-            self.jastrow_type = 'JastrowFactorCombinedTerms'
-
-            self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
-                torch.as_tensor(self.mol.atom_coords),
-                jastrow_kernel=jastrow_kernel,
-                jastrow_kernel_kwargs=jastrow_kernel_kwargs,
-                cuda=cuda)
-
-            if self.cuda:
-                for term in self.jastrow.jastrow_terms:
-                    term = term.to(self.device)
-
-        self.log_data()
diff --git a/qmctorch/wavefunction/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/slater_combined_jastrow_backflow.py
deleted file mode 100644
index 023ea286..00000000
--- a/qmctorch/wavefunction/slater_combined_jastrow_backflow.py
+++ /dev/null
@@ -1,291 +0,0 @@
-
-
-import numpy as np
-import torch
-from .slater_jastrow import SlaterJastrow
-
-import operator
-
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecElec
-from .jastrows.jastrow_factor_combined_terms import JastrowFactorCombinedTerms
-from .jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel as PadeJastrowKernelElecNuc
-
-
-from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from .orbitals.atomic_orbitals_orbital_dependent_backflow import AtomicOrbitalsOrbitalDependentBackFlow
-from .orbitals.backflow.kernels import BackFlowKernelInverse
-
-
-class SlaterManyBodyJastrowBackflow(SlaterJastrow):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel={
-                     'ee': PadeJastrowKernelElecElec,
-                     'en': PadeJastrowKernelElecNuc,
-                     'een': None},
-                 jastrow_kernel_kwargs={
-                     'ee': {},
-                     'en': {},
-                     'een': {}},
-                 backflow_kernel=BackFlowKernelInverse,
-                 backflow_kernel_kwargs={},
-                 orbital_dependent_backflow=False,
-                 cuda=False,
-                 include_all_mo=True):
-        """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:
-        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 (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 = SlaterManyBodyJastrowBackflow(mol, configs='cas(2,2)')
-        """
-
-        super().__init__(mol, configs, kinetic, None, {}, cuda, include_all_mo)
-
-        # process the backflow transformation
-        if orbital_dependent_backflow:
-            self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
-        else:
-            self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
-
-        if self.cuda:
-            self.ao = self.ao.to(self.device)
-
-        # process the Jastrow
-        if jastrow_kernel is not None:
-
-            for k in ['ee', 'en', 'een']:
-                if k not in jastrow_kernel.keys():
-                    jastrow_kernel[k] = None
-                if k not in jastrow_kernel_kwargs.keys():
-                    jastrow_kernel_kwargs[k] = None
-
-            self.use_jastrow = True
-            self.jastrow_type = 'JastrowFactorCombinedTerms'
-
-            self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
-                torch.as_tensor(self.mol.atom_coords),
-                jastrow_kernel=jastrow_kernel,
-                jastrow_kernel_kwargs=jastrow_kernel_kwargs,
-                cuda=cuda)
-
-            if self.cuda:
-                for term in self.jastrow.jastrow_terms:
-                    term = term.to(self.device)
-
-        self.log_data()
-
-    def forward(self, x, ao=None):
-        """computes the value of the wave function for the sampling points
-
-        .. math::
-            J(R) \\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)
-            ao (torch.tensor, optional): values of the atomic orbitals (Nbatch, Nelec, Nao)
-
-        Returns:
-            torch.tensor: values of the wave functions at each sampling point (Nbatch, 1)
-
-        Examples::
-            >>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-            >>> pos = torch.rand(500,6)
-            >>> vals = wf(pos)
-        """
-
-        # compute the jastrow from the pos
-        if self.use_jastrow:
-            J = self.jastrow(x)
-
-        # atomic orbital
-        if ao is None:
-            x = self.ao(x)
-        else:
-            x = ao
-
-        # molecular orbitals
-        x = self.mo_scf(x)
-
-        # mix the mos
-        x = self.mo(x)
-
-        # pool the mos
-        x = self.pool(x)
-
-        # compute the CI and return
-        if self.use_jastrow:
-            return J * self.fc(x)
-
-        else:
-            return self.fc(x)
-
-    def ao2mo(self, ao):
-        """transforms AO values in to MO values."""
-        return self.mo(self.mo_scf(ao))
-
-    def pos2mo(self, x, derivative=0, sum_grad=True):
-        """Compute the MO vals from the pos
-
-        Args:
-            x ([type]): [description]
-            derivative (int, optional): [description]. Defaults to 0.
-            sum_grad (bool, optional): [description]. Defaults to True.
-
-        Returns:
-            [type]: [description]
-        """
-
-        ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
-        return self.ao2mo(ao)
-
-    def kinetic_energy_jacobi(self, x,  **kwargs):
-        r"""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}
-                                                          + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)}
-                                                          + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}
-
-        The lapacian of the determinental part is computed via
-
-        .. math::
-            \\Delta_i \\Psi(R) \\sum_n c_n ( \\frac{\\Delta_i D_n^{u}}{D_n^{u}} +
-                                           \\frac{\\Delta_i D_n^{d}}{D_n^{d}} +
-                                           2 \\frac{\\nabla_i D_n^{u}}{D_n^{u}} \\frac{\\nabla_i D_n^{d}}{D_n^{d}} )
-                                           D_n^{u} D_n^{d}
-
-        Since the backflow orbitals are multi-electronic the laplacian of the determinants
-        are obtained
-
-        .. math::
-            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A) +
-                                             Tr(A^{-1} \\nabla A) Tr(A^{-1} \\nabla A) +
-                                             Tr( (A^{-1} \\nabla A) (A^{-1} \\nabla A ))
-
-
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            torch.tensor: values of the kinetic energy at each sampling points
-        """
-
-        # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
-
-        # get the mo values
-        mo = self.ao2mo(ao)
-        dmo = self.ao2mo(dao)
-        d2mo = self.ao2mo(d2ao)
-
-        # compute the value of the slater det
-        slater_dets = self.pool(mo)
-        sum_slater_dets = self.fc(slater_dets)
-
-        # compute ( tr(A_u^-1\Delta A_u) + tr(A_d^-1\Delta A_d) )
-        hess = self.pool.operator(mo, d2mo)
-
-        # compute (tr(A_u^-1\nabla A_u) and tr(A_d^-1\nabla A_d))
-        grad = self.pool.operator(mo, dmo, op=None)
-
-        # compute (tr((A_u^-1\nabla A_u)^2) + tr((A_d^-1\nabla A_d))^2)
-        grad2 = self.pool.operator(mo, dmo, op_squared=True)
-
-        # assemble the total second derivative term
-        hess = (hess.sum(0)
-                + operator.add(*[(g**2).sum(0) for g in grad])
-                - grad2.sum(0)
-                + 2 * operator.mul(*grad).sum(0))
-
-        hess = self.fc(hess * slater_dets) / sum_slater_dets
-
-        if self.use_jastrow is False:
-            return -0.5 * hess
-
-        # compute the Jastrow terms
-        jast, djast, d2jast = self.jastrow(x,
-                                           derivative=[0, 1, 2],
-                                           sum_grad=False)
-
-        # prepare the second derivative term d2Jast/Jast
-        # Nbatch x Nelec
-        d2jast = d2jast / jast
-
-        # prepare the first derivative term
-        djast = djast / jast.unsqueeze(-1)
-
-        # -> Nelec x Ndim x Nbatch
-        djast = djast.permute(2, 1, 0)
-
-        # -> [Nelec*Ndim] x Nbatch
-        djast = djast.reshape(-1, djast.shape[-1])
-
-        # prepare the grad of the dets
-        # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
-
-        # [Nelec*Ndim] x Nbatch
-        grad_val = grad_val.squeeze()
-
-        # assemble the derivaite terms
-        out = d2jast.sum(-1) + 2*(grad_val * djast).sum(0) + \
-            hess.squeeze(-1)
-
-        return -0.5 * out.unsqueeze(-1)
-
-    def gradients_jacobi(self, x, sum_grad=True):
-        """Computes the gradients of the wf using Jacobi's Formula
-
-        Args:
-            x ([type]): [description]
-        """
-        raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 583b3af5..8e6c5d78 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,21 +1,46 @@
-
-
-import numpy as np
 import torch
-from .slater_jastrow_base import SlaterJastrowBase
-
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from typing  import Union, Optional, List
+from typing_extensions import Self
+from scipy.optimize import curve_fit
+from copy import deepcopy
+import numpy as np
+from torch import nn
+from torch.nn.utils.parametrizations import orthogonal 
+import operator
+import matplotlib.pyplot as plt
 
+from linetimer import CodeTimer
 
-class SlaterJastrow(SlaterJastrowBase):
+from .. import log
 
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+from ..scf import Molecule
+from .wf_base import WaveFunction
+from .orbitals.backflow.backflow_transformation import BackFlowTransformation
+from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .jastrows.elec_elec.kernels import PadeJastrowKernel
+from .jastrows.combine_jastrow import CombineJastrow
+from .orbitals.atomic_orbitals import AtomicOrbitals
+from .orbitals.molecular_orbitals import MolecularOrbitals
+from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
+from .pooling.slater_pooling import SlaterPooling
+from .pooling.orbital_configurations import OrbitalConfigurations
+from ..utils import register_extra_attributes
+from ..utils.constants import BOHR2ANGS 
+
+
+class SlaterJastrow(WaveFunction):
+    def __init__(
+        self,
+        mol: Molecule,
+        jastrow: Optional[Union[str, nn.Module, None]] = 'default',
+        backflow: Optional[Union[BackFlowTransformation, None]] = None,
+        configs: str = "ground_state",
+        kinetic: str = "jacobi",
+        cuda: bool = False,
+        include_all_mo: bool = True,
+        mix_mo: bool = False,
+        orthogonalize_mo: bool = False
+    ) ->  None:
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
         .. math::
@@ -26,23 +51,24 @@ def __init__(self, mol, configs='ground_state',
         .. math::
             J(r) = \\exp\\left( K_{ee}(r) \\right)
 
-        with K, a kernel function depending only on the electron-eletron distances 
+        with K, a kernel function depending only on the electron-eletron distances
 
         Args:
             mol (Molecule): a QMCTorch molecule object
+            jastrow (str, optional) : Class that computes the jastrow kernels. Defaults to 'default'.
+            backflow (BackFlowKernelBase, optional) : kernel function of the backflow transformation. Defaults to None.
             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(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                   
+                - 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 
+                - 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 Fals   e.
+            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
+            orthogonalize_mo (bool, optional): orthogonalize the molecular orbitals. Defaults to False
         Examples::
             >>> from qmctorch.scf import Molecule
             >>> from qmctorch.wavefunction import SlaterJastrow
@@ -50,23 +76,166 @@ def __init__(self, mol, configs='ground_state',
             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
 
-        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
+        super().__init__(mol.nelec, 3, kinetic, cuda)
+
+        # check for cuda
+        if not torch.cuda.is_available and self.cuda:
+            raise ValueError("Cuda not available, use cuda=False")
+
+        # check for conf/mo size
+        if not include_all_mo and configs.startswith("cas("):
+            raise ValueError("CAS calculation only possible with include_all_mo=True")
+
+        # molecule/atoms
+        self.mol = mol
+        self.atoms = mol.atoms
+        self.natom = mol.natom
+
+        # electronic confs
+        self.init_config(configs)
+
+        # atomic orbitals init
+        self.init_atomic_orb(backflow)
+
+        # init mo layer
+        self.init_molecular_orb(include_all_mo, mix_mo, orthogonalize_mo)
+
+        # initialize the slater det calculator
+        self.init_slater_det_calculator()
+
+        # initialize the fully connected layer
+        self.init_fc_layer()
+
+        # init the jastrow
+        self.init_jastrow(jastrow)
+
+        # init the knientic calc methods
+        self.init_kinetic(kinetic, backflow)
+
+        # register the callable for hdf5 dump
+        register_extra_attributes(self, ["ao", "mo", "jastrow", "pool", "fc"])
 
-        # process the Jastrow
-        if jastrow_kernel is not None:
+        self.log_data()
 
+    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None])-> None:
+        """Initialize the atomic orbital layer."""
+        # self.backflow = backflow
+        if backflow is None:
+            self.use_backflow = False
+            self.ao = AtomicOrbitals(self.mol, self.cuda)
+        else:
+            self.use_backflow = True
+            self.backflow_type = backflow.__repr__()
+            self.ao = AtomicOrbitalsBackFlow(self.mol, backflow, self.cuda)
+
+        if self.cuda:
+            self.ao = self.ao.to(self.device)
+
+    def init_molecular_orb(self, include_all_mo, mix_mo, orthogonalize_mo):
+        """initialize the molecular orbital layers"""
+
+        # # determine which orbs to include in the transformation
+        self.include_all_mo = include_all_mo
+        self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
+
+        self.mo = MolecularOrbitals(self.mol, 
+                                    include_all_mo, 
+                                    self.highest_occ_mo, 
+                                    mix_mo,
+                                    orthogonalize_mo,
+                                    self.cuda)
+
+        if self.cuda:
+            self.mo.to(self.device)
+            
+
+    def init_config(self, configs: str)-> None:
+        """Initialize the electronic configurations desired in the wave function."""
+
+        # define the SD we want
+        self.orb_confs = OrbitalConfigurations(self.mol)
+        if isinstance(configs, str):
+            self.configs_method = configs
+        elif isinstance(configs, tuple):
+            self.configs_method = "explicit"
+        self.configs = self.orb_confs.get_configs(configs)
+        self.nci = len(self.configs[0])
+        self.highest_occ_mo = max(self.configs[0].max(), self.configs[1].max()) + 1
+
+    def init_slater_det_calculator(self)-> None:
+        """Initialize the calculator of the slater dets"""
+
+        #  define the SD pooling layer
+        self.pool = SlaterPooling(
+            self.configs_method, self.configs, self.mol, self.cuda
+        )
+
+    def init_fc_layer(self)-> None:
+        """Init the fc layer"""
+
+        # init the layer
+        self.fc = nn.Linear(self.nci, 1, bias=False)
+
+        # set all weight to 0 except the groud state
+        self.fc.weight.data.fill_(0.0)
+        self.fc.weight.data[0][0] = 1.0
+
+        # port to card
+        if self.cuda:
+            self.fc = self.fc.to(self.device)
+
+    def init_jastrow(self, jastrow: Union[str, nn.Module, None]) -> None:
+        """Init the jastrow factor calculator"""
+
+        # if the jastrow is explicitly None we disable the factor
+        if jastrow is None:
+            self.jastrow = jastrow
+            self.use_jastrow = False
+
+        # otherwise we use the jastrow provided by the user
+        else:
             self.use_jastrow = True
-            self.jastrow_type = jastrow_kernel.__name__
-            self.jastrow = JastrowFactorElectronElectron(
-                self.mol.nup, self.mol.ndown, jastrow_kernel,
-                kernel_kwargs=jastrow_kernel_kwargs, cuda=cuda)
 
+            # create a simple Pade Jastrow factor as default
+            if jastrow == 'default':
+                self.jastrow = JastrowFactorElectronElectron(self.mol, 
+                                                             PadeJastrowKernel, 
+                                                             cuda=self.cuda)
+
+            elif isinstance(jastrow, list):
+                self.jastrow = CombineJastrow(jastrow)
+
+            elif isinstance(jastrow, nn.Module):
+                self.jastrow = jastrow
+
+            else:
+                raise TypeError('Jastrow factor not supported.')
+
+            self.jastrow_type = self.jastrow.__repr__()
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
 
-        self.log_data()
+    def set_combined_jastrow(self, jastrow: nn.Module):
+        """Initialize the jastrow factor as a sum of jastrows"""
+        self.jastrow = CombineJastrow(jastrow)
+
+    def init_kinetic(self, kinetic: str, backflow: Union[BackFlowTransformation,None]) -> None:
+        """ "Init the calculator of the kinetic energies"""
 
-    def forward(self, x, ao=None):
+        self.kinetic_method = kinetic
+        if kinetic == "jacobi":
+            if backflow is None:
+                self.kinetic_energy = self.kinetic_energy_jacobi
+
+            else:
+                self.gradients_jacobi = self.gradients_jacobi_backflow
+                self.kinetic_energy_jacobi = self.kinetic_energy_jacobi_backflow
+                self.kinetic_energy = self.kinetic_energy_jacobi_backflow
+
+    def forward(self, 
+                x: torch.Tensor, 
+                ao: Optional[Union[torch.Tensor, None]] = None
+                ) -> torch.Tensor:
         """computes the value of the wave function for the sampling points
 
         .. math::
@@ -86,6 +255,7 @@ def forward(self, x, ao=None):
             >>> vals = wf(pos)
         """
 
+        # compute the jastrow from the pos
         if self.use_jastrow:
             J = self.jastrow(x)
 
@@ -96,38 +266,42 @@ def forward(self, x, ao=None):
             x = ao
 
         # molecular orbitals
-        x = self.mo_scf(x)
-
-        # mix the mos
         x = self.mo(x)
 
         # pool the mos
         x = self.pool(x)
 
+        # compute the CI and return
         if self.use_jastrow:
             return J * self.fc(x)
 
-        else:
-            return self.fc(x)
-
-    def ao2mo(self, ao):
-        return self.mo(self.mo_scf(ao))
+        # if we do not have a Jastrow
+        return self.fc(x)
 
-    def pos2mo(self, x, derivative=0):
-        """Get the values of MOs
+    def ao2mo(self, ao:torch.Tensor) -> torch.Tensor:
+        """transforms AO values in to MO values."""
+        return self.mo(ao)
 
-        Arguments:
-            x {torch.tensor} -- positions of the electrons [nbatch, nelec*ndim]
+    def pos2mo(self, 
+               x: torch.Tensor, 
+               derivative: Optional[int] = 0, 
+               sum_grad: Optional[bool] = True
+               ) -> torch.Tensor:
+        """Compute the MO vals from the pos
 
-        Keyword Arguments:
-            derivative {int} -- order of the derivative (default: {0})
+        Args:
+            x ([type]): [description]
+            derivative (int, optional): [description]. Defaults to 0.
+            sum_grad (bool, optional): [description]. Defaults to True.
 
         Returns:
-            torch.tensor -- MO matrix [nbatch, nelec, nmo]
+            [type]: [description]
         """
-        return self.mo(self.mo_scf(self.ao(x, derivative=derivative)))
 
-    def kinetic_energy_jacobi(self, x, **kwargs):
+        ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
+        return self.ao2mo(ao)
+
+    def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
@@ -152,6 +326,7 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         """
 
         ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
+
         mo = self.ao2mo(ao)
         bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
 
@@ -160,7 +335,11 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         out = self.fc(kin * psi) / self.fc(psi)
         return out
 
-    def gradients_jacobi(self, x, sum_grad=False, pdf=False):
+    def gradients_jacobi(self, 
+                         x: torch.Tensor, 
+                         sum_grad: Optional[bool] = False, 
+                         pdf: Optional[bool] = False
+                         ) -> torch.Tensor:
         """Compute the gradients of the wave function (or density) using the Jacobi Formula
         C. Filippi, Simple Formalism for Efficient Derivatives.
 
@@ -175,7 +354,7 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
         are computed following
 
         .. math::
-            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \Sigma \\right)
+            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \\Sigma \\right)
 
         with
 
@@ -232,7 +411,6 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
         out = out.transpose(0, 1).squeeze()
 
         if self.use_jastrow:
-
             nbatch = x.shape[0]
 
             # nbatch x 1
@@ -245,11 +423,10 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
             grad_jast = grad_jast.permute(0, 2, 1)
 
             # compute J(R) (\nabla\Sigma)
-            out = jast*out
+            out = jast * out
 
             # add the product (\nabla J(R)) \Sigma
-            out = out + \
-                (grad_jast * self.fc(dets).unsqueeze(-1)).reshape(nbatch, -1)
+            out = out + (grad_jast * self.fc(dets).unsqueeze(-1)).reshape(nbatch, -1)
 
         # compute the gradient of the pdf (i.e. the square of the wave function)
         # \nabla f^2 = 2 (\nabla f) f
@@ -260,7 +437,13 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
 
         return out
 
-    def get_kinetic_operator(self, x, ao, dao, d2ao,  mo):
+    def get_kinetic_operator(self, 
+                             x: torch.Tensor, 
+                             ao: torch.Tensor, 
+                             dao: torch.Tensor, 
+                             d2ao: torch.Tensor, 
+                             mo: torch.Tensor
+                             ) -> torch.Tensor:
         """Compute the Bkin matrix
 
         Args:
@@ -274,10 +457,7 @@ def get_kinetic_operator(self, x, ao, dao, d2ao,  mo):
         bkin = self.ao2mo(d2ao)
 
         if self.use_jastrow:
-
-            jast, djast, d2jast = self.jastrow(x,
-                                               derivative=[0, 1, 2],
-                                               sum_grad=False)
+            jast, djast, d2jast = self.jastrow(x, derivative=[0, 1, 2], sum_grad=False)
 
             djast = djast.transpose(1, 2) / jast.unsqueeze(-1)
             d2jast = d2jast / jast
@@ -290,3 +470,271 @@ def get_kinetic_operator(self, x, ao, dao, d2ao,  mo):
             bkin = bkin + 2 * djast_dmo + d2jast_mo
 
         return -0.5 * bkin
+
+    def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
+        """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}
+                                                          + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)}
+                                                          + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}
+
+        The lapacian of the determinental part is computed via
+
+        .. math::
+            \\Delta_i \\Psi(R) \\sum_n c_n ( \\frac{\\Delta_i D_n^{u}}{D_n^{u}} +
+                                           \\frac{\\Delta_i D_n^{d}}{D_n^{d}} +
+                                           2 \\frac{\\nabla_i D_n^{u}}{D_n^{u}} \\frac{\\nabla_i D_n^{d}}{D_n^{d}} )
+                                           D_n^{u} D_n^{d}
+
+        Since the backflow orbitals are multi-electronic the laplacian of the determinants
+        are obtained
+
+        .. math::
+            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A) +
+                                             Tr(A^{-1} \\nabla A) Tr(A^{-1} \\nabla A) +
+                                             Tr( (A^{-1} \\nabla A) (A^{-1} \\nabla A ))
+
+
+        Args:
+            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
+
+        Returns:
+            torch.tensor: values of the kinetic energy at each sampling points
+        """
+        silent_timer = True
+
+        # get ao values
+        with CodeTimer('Get AOs', silent=silent_timer):
+            ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
+
+        # get the mo values
+        with CodeTimer('Get MOs', silent=silent_timer):
+            mo = self.ao2mo(ao)
+            dmo = self.ao2mo(dao)
+            d2mo = self.ao2mo(d2ao)
+
+        # precompute the inverse of the MOs
+        with CodeTimer('Get Inverse MOs', silent=silent_timer):
+            inv_mo = self.pool.compute_inverse_occupied_mo_matrix(mo)
+        
+        # compute the value of the slater det
+        with CodeTimer('Get SDs', silent=silent_timer):
+            slater_dets = self.pool(mo)
+            sum_slater_dets = self.fc(slater_dets)
+
+        # compute ( tr(A_u^-1\Delta A_u) + tr(A_d^-1\Delta A_d) )
+        with CodeTimer('Get Hess', silent=silent_timer):
+            hess = self.pool.operator(mo, d2mo, inv_mo=inv_mo)
+
+        # compute (tr(A_u^-1\nabla A_u) and tr(A_d^-1\nabla A_d))
+        with CodeTimer('Get Grad', silent=silent_timer):
+            grad = self.pool.operator(mo, dmo, op=None, inv_mo=inv_mo)
+
+        # compute (tr((A_u^-1\nabla A_u)^2) + tr((A_d^-1\nabla A_d))^2)
+        with CodeTimer('Get Grad2', silent=silent_timer):
+            grad2 = self.pool.operator(mo, dmo, op_squared=True, inv_mo=inv_mo)
+
+        # assemble the total second derivative term
+        with CodeTimer('Get Total', silent=silent_timer):
+            hess = (
+                hess.sum(0)
+                + operator.add(*[(g**2).sum(0) for g in grad])
+                - grad2.sum(0)
+                + 2 * operator.mul(*grad).sum(0)
+            )
+            
+            hess = self.fc(hess * slater_dets) / sum_slater_dets
+
+        if self.use_jastrow is False:
+            return -0.5 * hess
+
+        # compute the Jastrow terms
+        jast, djast, d2jast = self.jastrow(x, derivative=[0, 1, 2], sum_grad=False)
+
+        # prepare the second derivative term d2Jast/Jast
+        # Nbatch x Nelec
+        d2jast = d2jast / jast
+
+        # prepare the first derivative term
+        djast = djast / jast.unsqueeze(-1)
+
+        # -> Nelec x Ndim x Nbatch
+        djast = djast.permute(2, 1, 0)
+
+        # -> [Nelec*Ndim] x Nbatch
+        djast = djast.reshape(-1, djast.shape[-1])
+
+        # prepare the grad of the dets
+        # [Nelec*Ndim] x Nbatch x 1
+
+        grad_val = self.fc(operator.add(*grad) * slater_dets) / sum_slater_dets
+
+        # [Nelec*Ndim] x Nbatch
+        grad_val = grad_val.squeeze()
+
+        # assemble the derivaite terms
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
+        return -0.5 * out.unsqueeze(-1)
+
+    def gradients_jacobi_backflow(self, 
+                                  x: torch.Tensor, 
+                                  sum_grad: Optional[bool] = True, 
+                                  pdf: Optional[bool] = False):
+        """Computes the gradients of the wf using Jacobi's Formula
+
+        Args:
+            x ([type]): [description]
+        """
+        raise NotImplementedError(
+            "Gradient through Jacobi formula not implemented for backflow orbitals"
+        )
+
+    def log_data(self) -> None:
+        """Print information abut the wave function."""
+        log.info("")
+        log.info(" Wave Function")
+        log.info("  Backflow            : {0}", self.use_backflow)
+        if self.use_backflow:
+            log.info("  Backflow kernel     : {0}", self.backflow_type)
+        log.info("  Jastrow factor      : {0}", self.use_jastrow)
+        if self.use_jastrow:
+            log.info("  Jastrow kernel      : {0}", self.jastrow_type)
+        log.info("  Highest MO included : {0}", self.nmo_opt)
+        log.info("  Configurations      : {0}", self.configs_method)
+        log.info("  Number of confs     : {0}", self.nci)
+
+        log.debug("  Configurations      : ")
+        for ic in range(self.nci):
+            cstr = " " + " ".join([str(i) for i in self.configs[0][ic].tolist()])
+            cstr += " | " + " ".join([str(i) for i in self.configs[1][ic].tolist()])
+            log.debug(cstr)
+
+        log.info("  Kinetic energy      : {0}", self.kinetic_method)
+        log.info("  Number var  param   : {0}", self.get_number_parameters())
+        log.info("  Cuda support        : {0}", self.cuda)
+        if self.cuda:
+            log.info("  GPU                 : {0}", torch.cuda.get_device_name(0))
+
+    def update_mo_coeffs(self):
+        """Update the Mo coefficient during a GO run."""
+        self.mol.atom_coords = self.ao.atom_coords.detach().numpy().tolist()
+        self.mo.weight = self.get_mo_coeffs()
+
+    def geometry(self, pos: torch.Tensor, 
+                 convert_to_angs: Optional[bool] = False) -> List:
+        """Returns the gemoetry of the system in xyz format
+
+        Args:
+            pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
+
+        Returns:
+            list: list where each element is one line of the xyz file
+        """
+        d = []
+        convert = 1
+        if convert_to_angs:
+            convert = BOHR2ANGS
+        for iat in range(self.natom):
+            xyz = self.ao.atom_coords[iat, :].cpu().detach().numpy() * convert
+            d.append(xyz.tolist())
+        return d
+    
+    def forces(self) -> torch.Tensor:
+        """
+        Returns the gradient of the atomic coordinates with respect to the wave function.
+
+        Returns
+        -------
+        torch.Tensor
+            The gradient of the atomic coordinates as a PyTorch tensor.
+        """
+        return self.ao.atom_coords.grad
+
+    def gto2sto(self, plot: Optional[bool] = False) -> Self:
+        """Fits the AO GTO to AO STO.
+        The SZ sto that have only one basis function per ao
+        """
+
+        assert self.ao.radial_type.startswith("gto")
+        assert self.ao.harmonics_type == "cart"
+
+        log.info("  Fit GTOs to STOs  : ")
+
+        def sto(x, norm, alpha):
+            """Fitting function."""
+            return norm * np.exp(-alpha * np.abs(x))
+
+        # shortcut for nao
+        nao = self.mol.basis.nao
+
+        # create a new mol and a new basis
+        new_mol = deepcopy(self.mol)
+        basis = deepcopy(self.mol.basis)
+
+        # change basis to sto
+        basis.radial_type = "sto_pure"
+        basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
+
+        # reset basis data
+        basis.index_ctr = np.arange(nao)
+        basis.bas_coeffs = np.ones(nao)
+        basis.bas_exp = np.zeros(nao)
+        basis.bas_norm = np.zeros(nao)
+        basis.bas_kr = np.zeros(nao)
+        basis.bas_kx = np.zeros(nao)
+        basis.bas_ky = np.zeros(nao)
+        basis.bas_kz = np.zeros(nao)
+
+        # 2D fit space
+        x = torch.linspace(-5, 5, 501)
+
+        # compute the values of the current AOs using GTO BAS
+        pos = x.reshape(-1, 1).repeat(1, self.ao.nbas).to(self.device)
+        gto = self.ao.norm_cst * torch.exp(-self.ao.bas_exp * pos**2)
+        gto = gto.unsqueeze(1).repeat(1, self.nelec, 1)
+        ao = self.ao._contract(gto)[:, 0, :].detach().cpu().numpy()
+
+        # loop over AOs
+        for iorb in range(self.ao.norb):
+            # fit AO with STO
+            xdata = x.numpy()
+            ydata = ao[:, iorb]
+            popt, _ = curve_fit(sto, xdata, ydata)
+
+            # store new exp/norm
+            basis.bas_norm[iorb] = popt[0]
+            basis.bas_exp[iorb] = popt[1]
+
+            # determine k values
+            basis.bas_kx[iorb] = (
+                self.ao.harmonics.bas_kx[self.ao.index_ctr == iorb].unique().item()
+            )
+            basis.bas_ky[iorb] = (
+                self.ao.harmonics.bas_ky[self.ao.index_ctr == iorb].unique().item()
+            )
+            basis.bas_kz[iorb] = (
+                self.ao.harmonics.bas_kz[self.ao.index_ctr == iorb].unique().item()
+            )
+
+            # plot if necessary
+            if plot:
+                plt.plot(xdata, ydata)
+                plt.plot(xdata, sto(xdata, *popt))
+                plt.show()
+
+        # update basis in new mole
+        new_mol.basis = basis
+
+        # returns new orbital instance
+        return self.__class__(
+            new_mol,
+            self.jastrow,
+            backflow=self.ao.backflow_trans,
+            configs=self.configs_method,
+            kinetic=self.kinetic_method,
+            cuda=self.cuda,
+            include_all_mo=self.include_all_mo,
+        )
+
diff --git a/qmctorch/wavefunction/slater_jastrow_backflow.py b/qmctorch/wavefunction/slater_jastrow_backflow.py
deleted file mode 100644
index 38690d0a..00000000
--- a/qmctorch/wavefunction/slater_jastrow_backflow.py
+++ /dev/null
@@ -1,270 +0,0 @@
-
-
-import torch
-
-from torch import nn
-import operator
-
-from .. import log
-
-from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from .orbitals.atomic_orbitals_orbital_dependent_backflow import AtomicOrbitalsOrbitalDependentBackFlow
-from .slater_jastrow_base import SlaterJastrowBase
-from .orbitals.backflow.kernels import BackFlowKernelInverse
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
-
-
-class SlaterJastrowBackFlow(SlaterJastrowBase):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 backflow_kernel=BackFlowKernelInverse,
-                 backflow_kernel_kwargs={},
-                 orbital_dependent_backflow=False,
-                 cuda=False,
-                 include_all_mo=True):
-        """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:
-        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. 
-                - 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 = SlaterJastrowBackFlow(mol, configs='cas(2,2)')
-        """
-
-        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
-
-        # process the backflow transformation
-        if orbital_dependent_backflow:
-            self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
-        else:
-            self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
-
-        # process the Jastrow
-        self.jastrow = JastrowFactorElectronElectron(
-            self.mol.nup, self.mol.ndown, jastrow_kernel,
-            kernel_kwargs=jastrow_kernel_kwargs, cuda=cuda)
-
-        if jastrow_kernel is not None:
-            self.use_jastrow = True
-            self.jastrow_type = jastrow_kernel.__name__
-
-        if self.cuda:
-            self.jastrow = self.jastrow.to(self.device)
-            self.ao = self.ao.to(self.device)
-
-        self.log_data()
-
-    def forward(self, x, ao=None):
-        """computes the value of the wave function for the sampling points
-
-        .. math::
-            J(R) \\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)
-            ao (torch.tensor, optional): values of the atomic orbitals (Nbatch, Nelec, Nao)
-
-        Returns:
-            torch.tensor: values of the wave functions at each sampling point (Nbatch, 1)
-
-        Examples::
-            >>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-            >>> pos = torch.rand(500,6)
-            >>> vals = wf(pos)
-        """
-
-        # compute the jastrow from the pos
-        if self.use_jastrow:
-            J = self.jastrow(x)
-
-        # atomic orbital
-        if ao is None:
-            x = self.ao(x)
-        else:
-            x = ao
-
-        # molecular orbitals
-        x = self.mo_scf(x)
-
-        # mix the mos
-        x = self.mo(x)
-
-        # pool the mos
-        x = self.pool(x)
-
-        # compute the CI and return
-        if self.use_jastrow:
-            return J * self.fc(x)
-
-        else:
-            return self.fc(x)
-
-    def ao2mo(self, ao):
-        """transforms AO values in to MO values."""
-        return self.mo(self.mo_scf(ao))
-
-    def pos2mo(self, x, derivative=0, sum_grad=True):
-        """Compute the MO vals from the pos
-
-        Args:
-            x ([type]): [description]
-            derivative (int, optional): [description]. Defaults to 0.
-            sum_grad (bool, optional): [description]. Defaults to True.
-
-        Returns:
-            [type]: [description]
-        """
-
-        ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
-        return self.ao2mo(ao)
-
-    def kinetic_energy_jacobi(self, x,  **kwargs):
-        """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)}
-                                                          + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)}
-                                                          + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}
-
-        The lapacian of the determinental part is computed via
-
-        .. math::
-            \\Delta_i \\Psi(R) \\sum_n c_n ( \\frac{\\Delta_i D_n^{u}}{D_n^{u}} +
-                                           \\frac{\\Delta_i D_n^{d}}{D_n^{d}} +
-                                           2 \\frac{\\nabla_i D_n^{u}}{D_n^{u}} \\frac{\\nabla_i D_n^{d}}{D_n^{d}} )
-                                           D_n^{u} D_n^{d}
-
-        Since the backflow orbitals are multi-electronic the laplacian of the determinants
-        are obtained
-
-        .. math::
-            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A) +
-                                             Tr(A^{-1} \\nabla A) Tr(A^{-1} \\nabla A) +
-                                             Tr( (A^{-1} \\nabla A) (A^{-1} \\nabla A ))
-
-
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            torch.tensor: values of the kinetic energy at each sampling points
-        """
-
-        # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
-
-        # get the mo values
-        mo = self.ao2mo(ao)
-        dmo = self.ao2mo(dao)
-        d2mo = self.ao2mo(d2ao)
-
-        # compute the value of the slater det
-        slater_dets = self.pool(mo)
-        sum_slater_dets = self.fc(slater_dets)
-
-        # compute ( tr(A_u^-1\Delta A_u) + tr(A_d^-1\Delta A_d) )
-        hess = self.pool.operator(mo, d2mo)
-
-        # compute (tr(A_u^-1\nabla A_u) and tr(A_d^-1\nabla A_d))
-        grad = self.pool.operator(mo, dmo, op=None)
-
-        # compute (tr((A_u^-1\nabla A_u)^2) + tr((A_d^-1\nabla A_d))^2)
-        grad2 = self.pool.operator(mo, dmo, op_squared=True)
-
-        # assemble the total second derivative term
-        hess = (hess.sum(0)
-                + operator.add(*[(g**2).sum(0) for g in grad])
-                - grad2.sum(0)
-                + 2 * operator.mul(*grad).sum(0))
-
-        hess = self.fc(hess * slater_dets) / sum_slater_dets
-
-        if self.use_jastrow is False:
-            return -0.5 * hess
-
-        # compute the Jastrow terms
-        jast, djast, d2jast = self.jastrow(x,
-                                           derivative=[0, 1, 2],
-                                           sum_grad=False)
-
-        # prepare the second derivative term d2Jast/Jast
-        # Nbatch x Nelec
-        d2jast = d2jast / jast
-
-        # prepare the first derivative term
-        djast = djast / jast.unsqueeze(-1)
-
-        # -> Nelec x Ndim x Nbatch
-        djast = djast.permute(2, 1, 0)
-
-        # -> [Nelec*Ndim] x Nbatch
-        djast = djast.reshape(-1, djast.shape[-1])
-
-        # prepare the grad of the dets
-        # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
-
-        # [Nelec*Ndim] x Nbatch
-        grad_val = grad_val.squeeze()
-
-        # assemble the derivaite terms
-        out = d2jast.sum(-1) + 2*(grad_val * djast).sum(0) + \
-            hess.squeeze(-1)
-
-        return -0.5 * out.unsqueeze(-1)
-
-    def gradients_jacobi(self, x, sum_grad=True):
-        """Computes the gradients of the wf using Jacobi's Formula
-
-        Args:
-            x ([type]): [description]
-        """
-        raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
diff --git a/qmctorch/wavefunction/slater_jastrow_base.py b/qmctorch/wavefunction/slater_jastrow_base.py
deleted file mode 100644
index 3214b488..00000000
--- a/qmctorch/wavefunction/slater_jastrow_base.py
+++ /dev/null
@@ -1,357 +0,0 @@
-from copy import deepcopy
-
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-from scipy.optimize import curve_fit
-from torch import nn
-
-import torch
-from .. import log
-from ..utils import register_extra_attributes
-from .orbitals.atomic_orbitals import AtomicOrbitals
-from .pooling.orbital_configurations import OrbitalConfigurations
-from .pooling.slater_pooling import SlaterPooling
-from .wf_base import WaveFunction
-
-
-class SlaterJastrowBase(WaveFunction):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
-        """Implementation of the QMC Network.
-
-        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
-            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
-        """
-
-        super(SlaterJastrowBase, self).__init__(
-            mol.nelec, 3, kinetic, cuda)
-
-        # check for cuda
-        if not torch.cuda.is_available and self.cuda:
-            raise ValueError('Cuda not available, use cuda=False')
-
-        # check for conf/mo size
-        if not include_all_mo and configs.startswith('cas('):
-            raise ValueError(
-                'CAS calculation only possible with include_all_mo=True')
-
-        # number of atoms
-        self.mol = mol
-        self.atoms = mol.atoms
-        self.natom = mol.natom
-
-        # define the SD we want
-        self.orb_confs = OrbitalConfigurations(mol)
-        self.configs_method = configs
-        self.configs = self.orb_confs.get_configs(configs)
-        self.nci = len(self.configs[0])
-        self.highest_occ_mo = torch.stack(self.configs).max()+1
-
-        # define the atomic orbital layer
-        self.ao = AtomicOrbitals(mol, cuda)
-
-        # define the mo layer
-        self.include_all_mo = include_all_mo
-        self.nmo_opt = mol.basis.nmo if include_all_mo else self.highest_occ_mo
-        self.mo_scf = nn.Linear(
-            mol.basis.nao, self.nmo_opt, bias=False)
-        self.mo_scf.weight = self.get_mo_coeffs()
-        self.mo_scf.weight.requires_grad = False
-        if self.cuda:
-            self.mo_scf.to(self.device)
-
-        # define the mo mixing layer
-        # self.mo = nn.Linear(mol.basis.nmo, self.nmo_opt, bias=False)
-        self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
-        self.mo.weight = nn.Parameter(
-            torch.eye(self.nmo_opt, self.nmo_opt))
-        if self.cuda:
-            self.mo.to(self.device)
-
-        # jastrow
-        self.jastrow_type = None
-        self.use_jastrow = False
-
-        #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method,
-                                  self.configs, mol, cuda)
-
-        # define the linear layer
-        self.fc = nn.Linear(self.nci, 1, bias=False)
-        self.fc.weight.data.fill_(0.)
-        self.fc.weight.data[0][0] = 1.
-
-        if self.cuda:
-            self.fc = self.fc.to(self.device)
-
-        self.kinetic_method = kinetic
-        if kinetic == 'jacobi':
-            self.kinetic_energy = self.kinetic_energy_jacobi
-
-        gradients = 'auto'
-        self.gradients_method = gradients
-        if gradients == 'jacobi':
-            self.gradients = self.gradients_jacobi
-
-        if self.cuda:
-            self.device = torch.device('cuda')
-            self.to(self.device)
-
-        # register the callable for hdf5 dump
-        register_extra_attributes(self,
-                                  ['ao', 'mo_scf',
-                                   'mo', 'jastrow',
-                                   'pool', 'fc'])
-
-    def log_data(self):
-        """Print information abut the wave function."""
-        log.info('')
-        log.info(' Wave Function')
-        log.info('  Jastrow factor      : {0}', self.use_jastrow)
-        if self.use_jastrow:
-            log.info(
-                '  Jastrow kernel      : {0}', self.jastrow_type)
-        log.info('  Highest MO included : {0}', self.nmo_opt)
-        log.info('  Configurations      : {0}', self.configs_method)
-        log.info('  Number of confs     : {0}', self.nci)
-
-        log.debug('  Configurations      : ')
-        for ic in range(self.nci):
-            cstr = ' ' + ' '.join([str(i)
-                                   for i in self.configs[0][ic].tolist()])
-            cstr += ' | ' + ' '.join([str(i)
-                                      for i in self.configs[1][ic].tolist()])
-            log.debug(cstr)
-
-        log.info('  Kinetic energy      : {0}', self.kinetic_method)
-        log.info(
-            '  Number var  param   : {0}', self.get_number_parameters())
-        log.info('  Cuda support        : {0}', self.cuda)
-        if self.cuda:
-            log.info(
-                '  GPU                 : {0}', torch.cuda.get_device_name(0))
-
-    def get_mo_coeffs(self):
-        mo_coeff = torch.as_tensor(self.mol.basis.mos).type(
-            torch.get_default_dtype())
-        if not self.include_all_mo:
-            mo_coeff = mo_coeff[:, :self.highest_occ_mo]
-        return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
-
-    def update_mo_coeffs(self):
-        self.mol.atom_coords = self.ao.atom_coords.detach().numpy().tolist()
-        self.mo.weight = self.get_mo_coeffs()
-
-    def geometry(self, pos):
-        """Returns the gemoetry of the system in xyz format
-
-        Args:
-            pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            list: list where each element is one line of the xyz file
-        """
-        d = []
-        for iat in range(self.natom):
-
-            xyz = self.ao.atom_coords[iat,
-                                      :].cpu().detach().numpy().tolist()
-            d.append(xyz)
-        return d
-
-    def gto2sto(self, plot=False):
-        """Fits the AO GTO to AO STO.
-            The SZ sto that have only one basis function per ao
-        """
-
-        assert(self.ao.radial_type.startswith('gto'))
-        assert(self.ao.harmonics_type == 'cart')
-
-        log.info('  Fit GTOs to STOs  : ')
-
-        def sto(x, norm, alpha):
-            """Fitting function."""
-            return norm * np.exp(-alpha * np.abs(x))
-
-        # shortcut for nao
-        nao = self.mol.basis.nao
-
-        # create a new mol and a new basis
-        new_mol = deepcopy(self.mol)
-        basis = deepcopy(self.mol.basis)
-
-        # change basis to sto
-        basis.radial_type = 'sto_pure'
-        basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
-
-        # reset basis data
-        basis.index_ctr = np.arange(nao)
-        basis.bas_coeffs = np.ones(nao)
-        basis.bas_exp = np.zeros(nao)
-        basis.bas_norm = np.zeros(nao)
-        basis.bas_kr = np.zeros(nao)
-        basis.bas_kx = np.zeros(nao)
-        basis.bas_ky = np.zeros(nao)
-        basis.bas_kz = np.zeros(nao)
-
-        # 2D fit space
-        x = torch.linspace(-5, 5, 501)
-
-        # compute the values of the current AOs using GTO BAS
-        pos = x.reshape(-1, 1).repeat(1, self.ao.nbas).to(self.device)
-        gto = self.ao.norm_cst * torch.exp(-self.ao.bas_exp*pos**2)
-        gto = gto.unsqueeze(1).repeat(1, self.nelec, 1)
-        ao = self.ao._contract(gto)[
-            :, 0, :].detach().cpu().numpy()
-
-        # loop over AOs
-        for iorb in range(self.ao.norb):
-
-            # fit AO with STO
-            xdata = x.numpy()
-            ydata = ao[:, iorb]
-            popt, pcov = curve_fit(sto, xdata, ydata)
-
-            # store new exp/norm
-            basis.bas_norm[iorb] = popt[0]
-            basis.bas_exp[iorb] = popt[1]
-
-            # determine k values
-            basis.bas_kx[iorb] = self.ao.harmonics.bas_kx[self.ao.index_ctr == iorb].unique(
-            ).item()
-            basis.bas_ky[iorb] = self.ao.harmonics.bas_ky[self.ao.index_ctr == iorb].unique(
-            ).item()
-            basis.bas_kz[iorb] = self.ao.harmonics.bas_kz[self.ao.index_ctr == iorb].unique(
-            ).item()
-
-            # plot if necessary
-            if plot:
-                plt.plot(xdata, ydata)
-                plt.plot(xdata, sto(xdata, *popt))
-                plt.show()
-
-        # update basis in new mole
-        new_mol.basis = basis
-
-        # returns new orbital instance
-        return self.__class__(new_mol, configs=self.configs_method,
-                              kinetic=self.kinetic_method,
-                              cuda=self.cuda,
-                              include_all_mo=self.include_all_mo)
-
-    def forward(self, x, ao=None):
-        """computes the value of the wave function for the sampling points
-
-        .. math::
-            \\Psi(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)
-            ao (torch.tensor, optional): values of the atomic orbitals (Nbatch, Nelec, Nao)
-
-        Returns:
-            torch.tensor: values of the wave functions at each sampling point (Nbatch, 1)
-
-        Examples::
-            >>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-            >>> pos = torch.rand(500,6)
-            >>> vals = wf(pos)
-        """
-
-        raise NotImplementedError('Implement a forward method')
-
-    def ao2mo(self, ao):
-        """Get the values of the MO from the values of AO."""
-        raise NotImplementedError('Implement a ao2mo method')
-
-    def pos2mo(self, x, derivative=0):
-        """Get the values of MOs from the positions
-
-        Arguments:
-            x {torch.tensor} -- positions of the electrons [nbatch, nelec*ndim]
-
-        Keyword Arguments:
-            derivative {int} -- order of the derivative (default: {0})
-
-        Returns:
-            torch.tensor -- MO matrix [nbatch, nelec, nmo]
-        """
-        raise NotImplementedError('Implement a get_mo_vals method')
-
-    def kinetic_energy_jacobi(self, x,  **kwargs):
-        """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})
-
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            torch.tensor: values of the kinetic energy at each sampling points
-        """
-
-        raise NotImplementedError(
-            'Implement a kinetic_energy_jacobi method')
-
-    def gradients_jacobi(self, x, pdf=False):
-        """Compute the gradients of the wave function (or density) using the Jacobi Formula
-        C. Filippi, Simple Formalism for Efficient Derivatives.
-
-        .. math::
-             \\frac{K(R)}{\Psi(R)} = Tr(A^{-1} B_{grad})
-
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-            pdf (bool, optional) : if true compute the grads of the density
-
-        Returns:
-            torch.tensor: values of the gradients wrt the walker pos at each sampling points
-        """
-
-        raise NotImplementedError(
-            'Implement a gradient_jacobi method')
-
-    def get_gradient_operator(self, x, ao, grad_ao, mo):
-        """Compute the gradient operator
-
-        Args:
-            x ([type]): [description]
-            ao ([type]): [description]
-            dao ([type]): [description]
-        """
-
-        raise NotImplementedError(
-            'Implement a get_grad_operator method')
-
-    def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
-        """Compute the Bkin matrix
-
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-            mo (torch.tensor, optional): precomputed values of the MOs
-
-        Returns:
-            torch.tensor: matrix of the kinetic operator
-        """
-
-        raise NotImplementedError(
-            'Implement a get_kinetic_operator method')
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 13ebda9f..367bf808 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -1,20 +1,26 @@
 import torch
 import operator
-
-from .slater_jastrow_base import SlaterJastrowBase
+from typing import Union, Dict, Tuple
+from .slater_jastrow import SlaterJastrow
+from .jastrows.elec_elec.kernels.jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
-
-
-class SlaterOrbitalDependentJastrow(SlaterJastrowBase):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+from .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from  ..scf import Molecule
+
+
+class SlaterOrbitalDependentJastrow(SlaterJastrow):
+    def __init__(
+        self,
+        mol: Molecule,
+        configs: str = "ground_state",
+        kinetic: str = "jacobi",
+        jastrow_kernel: JastrowKernelElectronElectronBase = PadeJastrowKernel,
+        jastrow_kernel_kwargs: Dict = {},
+        cuda: bool = False,
+        include_all_mo: bool = True,
+    ) -> None:
         """Slater Jastrow Wave function with an orbital dependent Electron-Electron Jastrow Factor
 
         .. math::
@@ -23,17 +29,17 @@ def __init__(self, mol,
         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) 
+            \\phi_i(r) \\rightarrow J_i(r) \\phi_i(r)
 
         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(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                   
+                - 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 
+                - 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
@@ -49,17 +55,20 @@ def __init__(self, mol,
 
         if jastrow_kernel is None:
             raise ValueError(
-                'Orbital dependent Jastrow factor requires a valid jastrow kernel.')
+                "Orbital dependent Jastrow factor requires a valid jastrow kernel."
+            )
 
-        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
+        super().__init__(mol, None, None, configs, kinetic, cuda, include_all_mo)
         self.use_jastrow = True
 
         self.jastrow = JastrowFactorElectronElectron(
-            self.mol.nup, self.mol.ndown, jastrow_kernel,
+            mol,
+            jastrow_kernel,
             kernel_kwargs=jastrow_kernel_kwargs,
             orbital_dependent_kernel=True,
             number_of_orbitals=self.nmo_opt,
-            cuda=self.cuda)
+            cuda=self.cuda,
+        )
 
         if self.cuda:
             self.jastrow = self.jastrow.to(self.device)
@@ -68,7 +77,7 @@ def __init__(self, mol,
 
         self.log_data()
 
-    def ordered_jastrow(self, pos, derivative=0, sum_grad=True):
+    def ordered_jastrow(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Returns the value of the jastrow with the correct dimensions
 
         Args:
@@ -88,7 +97,7 @@ def ordered_jastrow(self, pos, derivative=0, sum_grad=True):
         """
         jast_vals = self.jastrow(pos, derivative, sum_grad)
 
-        def permute(vals):
+        def permute(vals: torch.Tensor) -> torch.Tensor:
             """transpose the data depending on the number of dim."""
             if vals.ndim == 3:
                 return vals.permute(1, 2, 0)
@@ -100,7 +109,7 @@ def permute(vals):
         else:
             return permute(jast_vals)
 
-    def forward(self, x, ao=None):
+    def forward(self, x: torch.Tensor, ao: Union[torch.Tensor, None]=None) -> torch.Tensor:
         """computes the value of the wave function for the sampling points
 
         .. math::
@@ -130,9 +139,6 @@ def forward(self, x, ao=None):
             x = ao
 
         # molecular orbitals
-        x = self.mo_scf(x)
-
-        # mix the mos
         x = self.mo(x)
 
         # jastrow for each orbital
@@ -145,12 +151,12 @@ def forward(self, x, ao=None):
         return self.fc(x)
 
     def ao2mo(self, ao):
-        return self.mo(self.mo_scf(ao))
+        return self.mo(ao)
 
     def ao2cmo(self, ao, jastrow):
-        return jastrow * self.mo(self.mo_scf(ao))
+        return jastrow * self.mo(ao)
 
-    def pos2mo(self, x, derivative=0, sum_grad=True):
+    def pos2mo(self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Compute the uncorrelated MOs from the positions."""
 
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
@@ -159,7 +165,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         else:
             return self.ao2mo(ao.transpose(2, 3)).transpose(2, 3)
 
-    def pos2cmo(self, x, derivative=0, sum_grad=True):
+    def pos2cmo(self, x: torch.Tensor, derivative:int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Get the values of correlated MOs
 
         Arguments:
@@ -175,21 +181,21 @@ def pos2cmo(self, x, derivative=0, sum_grad=True):
             return jast * mo
 
         elif derivative == 1:
-
             mo = self.pos2mo(x)
             dmo = self.pos2mo(x, derivative=1, sum_grad=sum_grad)
 
             jast = self.ordered_jastrow(x)
-            djast = self.ordered_jastrow(
-                x, derivative=1, sum_grad=sum_grad)
+            djast = self.ordered_jastrow(x, derivative=1, sum_grad=sum_grad)
 
             if sum_grad:
                 return mo * djast.sum(1).unsqueeze(1) + jast * dmo
             else:
-                return mo.unsqueeze(-1) * djast.sum(1).unsqueeze(1) + jast.unsqueeze(-1) * dmo
+                return (
+                    mo.unsqueeze(-1) * djast.sum(1).unsqueeze(1)
+                    + jast.unsqueeze(-1) * dmo
+                )
 
         elif derivative == 2:
-
             # atomic orbital
             ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
 
@@ -199,10 +205,9 @@ def pos2cmo(self, x, derivative=0, sum_grad=True):
             d2mo = self.ao2mo(d2ao)
 
             # jastrows
-            jast, djast, d2jast = self.ordered_jastrow(x,
-                                                       derivative=[
-                                                           0, 1, 2],
-                                                       sum_grad=False)
+            jast, djast, d2jast = self.ordered_jastrow(
+                x, derivative=[0, 1, 2], sum_grad=False
+            )
             # terms of the kin op
             jast_d2mo = d2mo * jast
             djast_dmo = (djast * dmo).sum(-1)
@@ -211,7 +216,7 @@ def pos2cmo(self, x, derivative=0, sum_grad=True):
             # assemble kin op
             return jast_d2mo + 2 * djast_dmo + d2jast_mo
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
@@ -246,15 +251,17 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         grad2 = self.pool.operator(cmo, bgrad, op_squared=True)
 
         # assemble the total kinetic values
-        kin = - 0.5 * (hess
-                       + operator.add(*[(g**2).sum(0) for g in grad])
-                       - grad2.sum(0)
-                       + 2 * operator.mul(*grad).sum(0))
+        kin = -0.5 * (
+            hess
+            + operator.add(*[(g**2).sum(0) for g in grad])
+            - grad2.sum(0)
+            + 2 * operator.mul(*grad).sum(0)
+        )
 
         # assemble
         return self.fc(kin * slater_dets) / self.fc(slater_dets)
 
-    def gradients_jacobi(self, x, sum_grad=True, pdf=False):
+    def gradients_jacobi(self, x: torch.Tensor, sum_grad: bool = True, pdf: bool = False) -> torch.Tensor:
         """Computes the gradients of the wf using Jacobi's Formula
 
         Args:
@@ -263,7 +270,8 @@ def gradients_jacobi(self, x, sum_grad=True, pdf=False):
 
         if pdf:
             raise NotImplementedError(
-                'Gradients of the pdf not implemented for ', self.__name__)
+                "Gradients of the pdf not implemented for ", self.__name__
+            )
 
         # get the CMO matrix
         cmo = self.pos2cmo(x)
@@ -287,7 +295,7 @@ def gradients_jacobi(self, x, sum_grad=True, pdf=False):
         # assemble
         return out
 
-    def get_hessian_operator(self, x):
+    def get_hessian_operator(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the Bkin matrix
 
         Args:
@@ -302,8 +310,7 @@ def get_hessian_operator(self, x):
         d2mo = self.pos2mo(x, derivative=2)
 
         jast = self.ordered_jastrow(x)
-        djast = self.ordered_jastrow(
-            x, derivative=1, sum_grad=False)
+        djast = self.ordered_jastrow(x, derivative=1, sum_grad=False)
         d2jast = self.ordered_jastrow(x, derivative=2)
 
         # \Delta_n J * MO
@@ -333,14 +340,14 @@ def get_hessian_operator(self, x):
         djast = djast.permute(1, 3, 0, 2).unsqueeze(-2)
 
         # \nabla jast \nabla mo
-        djast_dmo = (djast * dmo)
+        djast_dmo = djast * dmo
 
         # sum over ndim -> Nelec, Nbatch, Nelec, Nmo
         djast_dmo = djast_dmo.sum(1)
 
-        return d2mo_jast + d2jast_mo + 2*djast_dmo
+        return d2mo_jast + d2jast_mo + 2 * djast_dmo
 
-    def get_gradient_operator(self, x):
+    def get_gradient_operator(self, x: torch.Tensor) -> torch.Tensor:
         """Compute the gradient operator
 
         Args:
@@ -369,7 +376,7 @@ def get_gradient_operator(self, x):
         dmo = dmo.permute(2, 0, 1, 3, 4)
 
         # assemble the derivative
-        out = (mo * djast + dmo * jast)
+        out = mo * djast + dmo * jast
 
         # collapse the first two dimensions
         out = out.reshape(-1, *(out.shape[2:]))
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index 85fb5e55..b70ffccc 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -1,12 +1,23 @@
 import h5py
 import torch
+from typing import Optional
 from torch.autograd import Variable, grad
 
 
 class WaveFunction(torch.nn.Module):
+    def __init__(self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False):
+        """
+        Base class for wave functions.
 
-    def __init__(self, nelec, ndim, kinetic='auto', cuda=False):
+        Args:
+            nelec (int): number of electrons
+            ndim (int): number of dimensions
+            kinetic (str): kinetic energy type. Defaults to "auto".
+            cuda (bool): move the model to GPU. Defaults to False.
 
+        Returns:
+            None
+        """
         super(WaveFunction, self).__init__()
 
         self.ndim = ndim
@@ -14,14 +25,14 @@ def __init__(self, nelec, ndim, kinetic='auto', cuda=False):
         self.ndim_tot = self.nelec * self.ndim
         self.kinetic = kinetic
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
-            self.device = torch.device('cuda')
+            self.device = torch.device("cuda")
         self.kinetic_energy = self.kinetic_energy_autograd
         self.gradients = self.gradients_autograd
 
-    def forward(self, x):
-        ''' Compute the value of the wave function.
+    def forward(self, x: torch.Tensor):
+        """Compute the value of the wave function.
         for a multiple conformation of the electrons
 
         Args:
@@ -29,11 +40,11 @@ def forward(self, x):
             pos: position of the electrons
 
         Returns: values of psi
-        '''
+        """
 
         raise NotImplementedError()
 
-    def electronic_potential(self, pos):
+    def electronic_potential(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the electron-electron term
 
         .. math:
@@ -49,16 +60,14 @@ def electronic_potential(self, pos):
         pot = torch.zeros(pos.shape[0], device=self.device)
 
         for ielec1 in range(self.nelec - 1):
-            epos1 = pos[:, ielec1 *
-                        self.ndim:(ielec1 + 1) * self.ndim]
+            epos1 = pos[:, ielec1 * self.ndim : (ielec1 + 1) * self.ndim]
             for ielec2 in range(ielec1 + 1, self.nelec):
-                epos2 = pos[:, ielec2 *
-                            self.ndim:(ielec2 + 1) * self.ndim]
-                r = torch.sqrt(((epos1 - epos2)**2).sum(1))  # + 1E-12
-                pot += (1. / r)
+                epos2 = pos[:, ielec2 * self.ndim : (ielec2 + 1) * self.ndim]
+                r = torch.sqrt(((epos1 - epos2) ** 2).sum(1))  # + 1E-12
+                pot += 1.0 / r
         return pot.view(-1, 1)
 
-    def nuclear_potential(self, pos):
+    def nuclear_potential(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the electron-nuclear term
 
         .. math:
@@ -79,11 +88,11 @@ def nuclear_potential(self, pos):
             for iatom in range(self.natom):
                 patom = self.ao.atom_coords[iatom, :]
                 Z = self.ao.atomic_number[iatom]
-                r = torch.sqrt(((pelec - patom)**2).sum(1))  # + 1E-12
+                r = torch.sqrt(((pelec - patom) ** 2).sum(1))  # + 1E-12
                 p += -Z / r
         return p.view(-1, 1)
 
-    def nuclear_repulsion(self):
+    def nuclear_repulsion(self) -> torch.Tensor:
         r"""Computes the nuclear-nuclear repulsion term
 
         .. math:
@@ -93,18 +102,21 @@ def nuclear_repulsion(self):
             torch.tensor: values of the nuclear-nuclear energy at each sampling points
         """
 
-        vnn = 0.
+        vnn = 0.0
         for at1 in range(self.natom - 1):
             c0 = self.ao.atom_coords[at1, :]
             Z0 = self.ao.atomic_number[at1]
             for at2 in range(at1 + 1, self.natom):
                 c1 = self.ao.atom_coords[at2, :]
                 Z1 = self.ao.atomic_number[at2]
-                rnn = torch.sqrt(((c0 - c1)**2).sum())
+                rnn = torch.sqrt(((c0 - c1) ** 2).sum())
                 vnn += Z0 * Z1 / rnn
         return vnn
 
-    def gradients_autograd(self, pos, pdf=False):
+    def gradients_autograd(self, 
+                           pos: torch.Tensor, 
+                           pdf: Optional[bool] = False
+                           ) -> torch.Tensor:
         """Computes the gradients of the wavefunction (or density)
         w.r.t the values of the pos.
 
@@ -118,17 +130,15 @@ def gradients_autograd(self, pos, pdf=False):
         out = self.forward(pos)
 
         # compute the grads
-        grads = grad(out, pos,
-                     grad_outputs=torch.ones_like(out),
-                     only_inputs=True)[0]
+        grads = grad(out, pos, grad_outputs=torch.ones_like(out), only_inputs=True)[0]
 
         # if we return grad of pdf
         if pdf:
-            grads = 2*grads*out
+            grads = 2 * grads * out
 
         return grads
 
-    def kinetic_energy_autograd(self, pos):
+    def kinetic_energy_autograd(self, pos: torch.Tensor) -> torch.Tensor:
         """Compute the kinetic energy through the 2nd derivative
         w.r.t the value of the pos.
 
@@ -143,97 +153,96 @@ def kinetic_energy_autograd(self, pos):
 
         # compute the jacobian
         z = torch.ones_like(out)
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         # compute the diagonal element of the Hessian
         z = Variable(torch.ones(jacob.shape[0])).to(self.device)
         hess = torch.zeros(jacob.shape[0]).to(self.device)
 
         for idim in range(jacob.shape[1]):
-
-            tmp = grad(jacob[:, idim], pos,
-                       grad_outputs=z,
-                       only_inputs=True,
-                       create_graph=True)[0]
+            tmp = grad(
+                jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+            )[0]
 
             hess += tmp[:, idim]
 
         return -0.5 * hess.view(-1, 1) / out
 
-    def local_energy(self, pos):
+    def local_energy(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the local energy
 
-         .. math::
-             E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
+        .. math::
+            E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
 
-         Args:
-             pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-         Returns:
-             [torch.tensor]: values of the local enrgies at each sampling points
-
-         Examples::
-             >>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp')
-             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-             >>> pos = torch.rand(500,6)
-             >>> vals = wf.local_energy(pos)
+        Args:
+            pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
 
-         Note:
-            by default kinetic_energy refers to kinetic_energy_autograd
-            users can overwrite it to poit to any other methods
-            see kinetic_energy_jacobi in wf_orbital
-         """
+        Returns:
+            [torch.tensor]: values of the local enrgies at each sampling points
+
+        Examples::
+            >>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp')
+            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+            >>> pos = torch.rand(500,6)
+            >>> vals = wf.local_energy(pos)
+
+        Note:
+           by default kinetic_energy refers to kinetic_energy_autograd
+           users can overwrite it to poit to any other methods
+           see kinetic_energy_jacobi in wf_orbital
+        """
 
         ke = self.kinetic_energy(pos)
 
-        return ke  \
-            + self.nuclear_potential(pos)  \
-            + self.electronic_potential(pos) \
+        return (
+            ke
+            + self.nuclear_potential(pos)
+            + self.electronic_potential(pos)
             + self.nuclear_repulsion()
+        )
 
-    def energy(self, pos):
-        '''Total energy for the sampling points.'''
+    def energy(self, pos:torch.Tensor) -> torch.Tensor:
+        """Total energy for the sampling points."""
         return torch.mean(self.local_energy(pos))
 
-    def variance(self, pos):
-        '''Variance of the energy at the sampling points.'''
+    def variance(self, pos: torch.Tensor) -> torch.Tensor:
+        """Variance of the energy at the sampling points."""
         return torch.var(self.local_energy(pos))
 
-    def sampling_error(self, eloc):
-        '''Compute the statistical uncertainty.
-        Assuming the samples are uncorrelated.'''
+    def sampling_error(self, eloc: torch.Tensor) -> torch.Tensor:
+        """Compute the statistical uncertainty.
+        Assuming the samples are uncorrelated."""
         Npts = eloc.shape[0]
         return torch.sqrt(eloc.var() / Npts)
 
-    def _energy_variance(self, pos):
-        '''Return energy and variance.'''
+    def _energy_variance(self, pos: torch.Tensor) -> torch.Tensor:
+        """Return energy and variance."""
         el = self.local_energy(pos)
         return torch.mean(el), torch.var(el)
 
-    def _energy_variance_error(self, pos):
-        '''Return energy variance and sampling error.'''
+    def _energy_variance_error(self, pos: torch.Tensor) -> torch.Tensor:
+        """Return energy variance and sampling error."""
         el = self.local_energy(pos)
         return torch.mean(el), torch.var(el), self.sampling_error(el)
 
-    def pdf(self, pos, return_grad=False):
-        '''density of the wave function.'''
+    def pdf(self, pos: torch.Tensor, return_grad: Optional[bool]=False) -> torch.Tensor:
+        """density of the wave function."""
         if return_grad:
             return self.gradients(pos, pdf=True)
-        else:
-            return (self.forward(pos)**2).reshape(-1)
+        return (self.forward(pos) ** 2).reshape(-1)
 
-    def get_number_parameters(self):
+    def get_number_parameters(self) -> int:
         """Computes the total number of parameters."""
         nparam = 0
-        for name, param in self.named_parameters():
+        for _, param in self.named_parameters():
             if param.requires_grad:
                 nparam += param.data.numel()
         return nparam
 
-    def load(self, filename, group='wf_opt', model='best'):
+    def load(self, 
+             filename: str, 
+             group: Optional[str] = "wf_opt", 
+             model: Optional[str] = "best"):
         """Load trained parameters
 
         Args:
@@ -242,8 +251,8 @@ def load(self, filename, group='wf_opt', model='best'):
                                    Defaults to 'wf_opt'.
             model (str, optional): 'best' or ' last'. Defaults to 'best'.
         """
-        f5 = h5py.File(filename, 'r')
-        grp = f5[group]['models'][model]
+        f5 = h5py.File(filename, "r")
+        grp = f5[group]["models"][model]
         data = dict()
         for name, val in grp.items():
             data[name] = torch.as_tensor(val)
diff --git a/setup.py b/setup.py
index 8e111c6f..7a354a1c 100644
--- a/setup.py
+++ b/setup.py
@@ -41,12 +41,14 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch', 'plams',
-                      'pyscf', 'mendeleev', 'twiggy', 'mpi4py'],
+                      'scipy', 'tqdm', 'torch', 'h5py',
+                      'plams', 'pints', 'linetimer',
+                      'pyscf', 'mendeleev', 'twiggy',
+                      'plams', 'ase', 'rdkit', 'dgllife', 'dgl'],
 
     extras_require={
-        'hpc': ['horovod==0.27.0'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx'],
+        'hpc': ['horovod'],
+        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert','jupyter'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],
     }
diff --git a/tests/ase/test_ase_calc.py b/tests/ase/test_ase_calc.py
new file mode 100644
index 00000000..aa4c6e7b
--- /dev/null
+++ b/tests/ase/test_ase_calc.py
@@ -0,0 +1,68 @@
+import unittest
+
+from qmctorch.ase import QMCTorch     
+from qmctorch.ase.optimizer import TorchOptimizer
+from ase import Atoms 
+from ase.optimize import FIRE
+import torch
+import numpy as np
+
+class TestASEcalculator(unittest.TestCase):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        d = 0.70
+        self.h2 = Atoms('H2', positions=[(0, 0, -d/2), (0, 0, d/2)])
+
+        # instantiate the calc
+        self.h2.calc = QMCTorch()
+
+        # SCF options
+        self.h2.calc.scf_options.calculator = 'pyscf'
+        self.h2.calc.scf_options.basis = 'sto-3g'
+
+        # WF options
+        self.h2.calc.wf_options.configs = 'single_double(2,2)'
+        self.h2.calc.wf_options.orthogonalize_mo = False
+        self.h2.calc.wf_options.gto2sto = True
+        self.h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
+
+        # sampler options
+        self.h2.calc.sampler_options.nwalkers = 10
+        self.h2.calc.sampler_options.nstep  = 500
+        self.h2.calc.sampler_options.step_size = 0.5
+        self.h2.calc.sampler_options.ntherm = 400
+        self.h2.calc.sampler_options.ndecor = 10
+
+        # solver options
+        self.h2.calc.solver_options.freeze = []
+        self.h2.calc.solver_options.niter = 5
+        self.h2.calc.solver_options.tqdm = False
+        self.h2.calc.solver_options.grad = 'manual'
+
+        # options for the resampling
+        self.h2.calc.solver_options.resampling.mode = 'update'
+        self.h2.calc.solver_options.resampling.resample_every = 1
+        self.h2.calc.solver_options.resampling.ntherm_update = 10
+
+        # Optimize the wave function
+        self.h2.calc.initialize()
+
+    def test_calculate_energy(self):
+        self.h2.calc.calculate(properties=['energy'])
+
+    def test_calculate_forces(self):
+        self.h2.calc.calculate(properties=['forces'])
+
+    def test_torch_optim(self):
+        dyn = TorchOptimizer(self.h2, 
+                     trajectory='traj.xyz', 
+                     nepoch_wf_init=10, 
+                     nepoch_wf_update=5, 
+                     tqdm=False)
+        dyn.run(fmax=0.005, steps=2)
+
+    def test_fire_optim(self):
+        dyn = FIRE(self.h2, trajectory='traj.xyz')
+        dyn.run(fmax=0.005, steps=2)
diff --git a/tests/path_utils.py b/tests/path_utils.py
index 3e7d13af..382fd948 100644
--- a/tests/path_utils.py
+++ b/tests/path_utils.py
@@ -6,7 +6,7 @@
 __all__ = ["PATH_QMCTORCH", "PATH_TEST"]
 
 # Environment data
-PATH_QMCTORCH = Path(pkg.resource_filename('qmctorch', ''))
+PATH_QMCTORCH = Path(pkg.resource_filename("qmctorch", ""))
 ROOT = PATH_QMCTORCH.parent
 
 PATH_TEST = ROOT / "tests"
diff --git a/tests/sampler/test_generalized_metropolis.py b/tests/sampler/test_generalized_metropolis.py
index 70851a4b..46a57e87 100644
--- a/tests/sampler/test_generalized_metropolis.py
+++ b/tests/sampler/test_generalized_metropolis.py
@@ -5,15 +5,18 @@
 
 
 class TestGeneralizeMetropolis(TestSamplerBase):
-
     def test_gmh(self):
         """Test generalized MH."""
         sampler = GeneralizedMetropolis(
-            nwalkers=10, nstep=20, step_size=0.2,
-            nelec=self.wf.nelec, ndim=self.wf.ndim,
-            init=self.mol.domain('normal'))
+            nwalkers=10,
+            nstep=20,
+            step_size=0.2,
+            nelec=self.wf.nelec,
+            ndim=self.wf.ndim,
+            init=self.mol.domain("normal"),
+        )
 
-        pos = sampler(self.wf.pdf)
+        _ = sampler(self.wf.pdf)
 
 
 if __name__ == "__main__":
diff --git a/tests/sampler/test_hamiltonian.py b/tests/sampler/test_hamiltonian.py
index 88b866a3..40470744 100644
--- a/tests/sampler/test_hamiltonian.py
+++ b/tests/sampler/test_hamiltonian.py
@@ -5,7 +5,6 @@
 
 
 class TestHamiltonian(TestSamplerBase):
-
     def test_hmc(self):
         """Test HMC sampler."""
         sampler = Hamiltonian(
@@ -14,9 +13,10 @@ def test_hmc(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            init=self.mol.domain("normal"),
+        )
 
-        pos = sampler(self.wf.pdf)
+        _ = sampler(self.wf.pdf)
 
 
 if __name__ == "__main__":
diff --git a/tests/sampler/test_metropolis.py b/tests/sampler/test_metropolis.py
index 30ee9d2d..0ed9d98e 100644
--- a/tests/sampler/test_metropolis.py
+++ b/tests/sampler/test_metropolis.py
@@ -6,7 +6,6 @@
 
 
 class TestMetropolis(TestSamplerBase):
-
     def test_metropolis(self):
         """Test Metropolis sampling."""
 
@@ -16,13 +15,31 @@ def test_metropolis(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            init=self.mol.domain("normal"),
+        )
+
+        for m in ["one-elec", "all-elec", "all-elec-iter"]:
+            for p in ["normal", "uniform"]:
+                sampler.configure_move({"type": m, "proba": p})
+                _ = sampler(self.wf.pdf)
 
-        for m in ['one-elec', 'all-elec', 'all-elec-iter']:
-            for p in ['normal', 'uniform']:
+    def test_metropolis_logspace(self):
+        """Test Metropolis sampling in logspace."""
 
-                sampler.configure_move({'type': m, 'proba': p})
-                pos = sampler(self.wf.pdf)
+        sampler = Metropolis(
+            nwalkers=10,
+            nstep=20,
+            step_size=0.5,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            logspace=True,
+        )
+
+        for m in ["one-elec", "all-elec", "all-elec-iter"]:
+            for p in ["normal", "uniform"]:
+                sampler.configure_move({"type": m, "proba": p})
+                _ = sampler(self.wf.pdf)
 
 
 if __name__ == "__main__":
diff --git a/tests/sampler/test_metropolis_hasting.py b/tests/sampler/test_metropolis_hasting.py
new file mode 100644
index 00000000..e9a2206d
--- /dev/null
+++ b/tests/sampler/test_metropolis_hasting.py
@@ -0,0 +1,41 @@
+import unittest
+from qmctorch.sampler import MetropolisHasting
+from qmctorch.sampler.proposal_kernels import (
+    ConstantVarianceKernel,
+    CenterVarianceKernel,
+)
+from .test_sampler_base import TestSamplerBase
+
+
+class TestMetropolisHasting(TestSamplerBase):
+    def test_ConstantKernel(self):
+        """Test Metropolis sampling."""
+
+        sampler = MetropolisHasting(
+            nwalkers=10,
+            nstep=20,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            kernel=ConstantVarianceKernel(),
+        )
+
+        _ = sampler(self.wf.pdf)
+
+    def test_CenterVarianceKernel(self):
+        """Test Metropolis sampling."""
+
+        sampler = MetropolisHasting(
+            nwalkers=10,
+            nstep=20,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            kernel=CenterVarianceKernel(),
+        )
+
+        _ = sampler(self.wf.pdf)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/sampler/test_pints.py b/tests/sampler/test_pints.py
new file mode 100644
index 00000000..6bb11e35
--- /dev/null
+++ b/tests/sampler/test_pints.py
@@ -0,0 +1,41 @@
+import unittest
+
+
+import pints
+from qmctorch.sampler import PintsSampler
+from .test_sampler_base import TestSamplerBase
+
+
+class TestPints(TestSamplerBase):
+    def test_Haario(self):
+        """Test Metropolis sampling."""
+
+        sampler = PintsSampler(
+            nwalkers=10,
+            nstep=20,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            method=pints.HaarioBardenetACMC,
+        )
+
+        _ = sampler(self.wf.pdf)
+
+    def test_Langevin(self):
+        """Test Metropolis sampling."""
+
+        sampler = PintsSampler(
+            nwalkers=10,
+            nstep=20,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            method=pints.MALAMCMC,
+            method_requires_grad=True,
+        )
+
+        _ = sampler(self.wf.pdf)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index 7e928164..37862707 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -5,13 +5,16 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-class TestSamplerBase(unittest.TestCase):
 
+class TestSamplerBase(unittest.TestCase):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -19,10 +22,13 @@ def setUp(self):
 
         # molecule
         self.mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # orbital
-        self.wf = SlaterJastrow(self.mol)
+        self.wf = SlaterJastrow(self.mol, jastrow=jastrow)
diff --git a/tests/sampler/test_symmetry.py b/tests/sampler/test_symmetry.py
new file mode 100644
index 00000000..5136fad0
--- /dev/null
+++ b/tests/sampler/test_symmetry.py
@@ -0,0 +1,68 @@
+import unittest
+import torch
+from qmctorch.sampler.symmetry import planar_symmetry, Cinfv, Dinfh
+
+class TestPlanarSymmetry(unittest.TestCase):
+    def test_single_plane(self):
+        pos = torch.tensor([[1, 2, 3, 4, 5, 6]]).type(torch.float32)
+        plane = 'xy'
+        nelec = 2
+        ndim = 3
+        expected_out = torch.tensor([[1, 2, -3, 4, 5, -6]]).type(torch.float32)
+        out = planar_symmetry(pos, plane, nelec, ndim)
+        self.assertTrue(torch.allclose(out, expected_out))
+
+    def test_multiple_planes(self):
+        pos = torch.tensor([[1, 2, 3, 4, 5, 6]]).type(torch.float32)
+        plane = ['xy', 'xz']
+        nelec = 2
+        ndim = 3
+        expected_out = torch.tensor([[1, -2, -3, 4, -5, -6]]).type(torch.float32)
+        out = planar_symmetry(pos, plane, nelec, ndim)
+        self.assertTrue(torch.allclose(out, expected_out))
+
+
+    def test_inplace(self):
+        pos = torch.tensor([[1, 2, 3, 4, 5, 6]]).type(torch.float32)
+        plane = 'xy'
+        nelec = 2
+        ndim = 3
+        expected_out = torch.tensor([[1, 2, -3, 4, 5, -6]]).type(torch.float32)
+        out = planar_symmetry(pos, plane, nelec, ndim, inplace=True)
+        self.assertTrue(torch.allclose(out, expected_out))
+
+    def test_invalid_plane(self):
+        pos = torch.tensor([[1, 2, 3, 4, 5, 6]]).type(torch.float32)
+        plane = 'invalid'
+        nelec = 2
+        ndim = 3
+        with self.assertRaises(KeyError):
+            planar_symmetry(pos, plane, nelec, ndim)
+
+
+class TestDinfh(unittest.TestCase):
+
+    def setUp(self):
+        self.symmetry = Dinfh('x')  # Initialize Dinfh symmetry
+        self.pos = torch.randn(1, 6)  # Initialize pos tensor
+
+    def test_valid_input(self):
+        output = self.symmetry(self.pos)
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertEqual(output.shape, (8, 6))  # Check shape of output
+
+
+class TestCinfv(unittest.TestCase):
+
+    def setUp(self):
+        self.symmetry = Cinfv('x')  # Initialize Dinfh symmetry
+        self.pos = torch.randn(1, 6)  # Initialize pos tensor
+
+    def test_valid_input(self):
+        output = self.symmetry(self.pos)
+        self.assertIsInstance(output, torch.Tensor)
+        self.assertEqual(output.shape, (4, 6))  # Check shape of output
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/tests/sampler/test_walker.py b/tests/sampler/test_walker.py
index 3554311b..6770a7d8 100644
--- a/tests/sampler/test_walker.py
+++ b/tests/sampler/test_walker.py
@@ -5,24 +5,23 @@
 
 
 class TestWalkers(TestSamplerBase):
-
     def test_walkers_init(self):
         """Test different initialization methods of the walkers."""
-        w1 = Walkers(nwalkers=10,
-                     nelec=self.mol.nelec, ndim=3,
-                     init=self.mol.domain('center'))
+        _ = Walkers(
+            nwalkers=10, nelec=self.mol.nelec, ndim=3, init=self.mol.domain("center")
+        )
 
-        w2 = Walkers(nwalkers=10,
-                     nelec=self.mol.nelec, ndim=3,
-                     init=self.mol.domain('uniform'))
+        _ = Walkers(
+            nwalkers=10, nelec=self.mol.nelec, ndim=3, init=self.mol.domain("uniform")
+        )
 
-        w3 = Walkers(nwalkers=10,
-                     nelec=self.mol.nelec, ndim=3,
-                     init=self.mol.domain('normal'))
+        _ = Walkers(
+            nwalkers=10, nelec=self.mol.nelec, ndim=3, init=self.mol.domain("normal")
+        )
 
-        w4 = Walkers(nwalkers=10,
-                     nelec=self.mol.nelec, ndim=3,
-                     init=self.mol.domain('atomic'))
+        _ = Walkers(
+            nwalkers=10, nelec=self.mol.nelec, ndim=3, init=self.mol.domain("atomic")
+        )
 
 
 if __name__ == "__main__":
diff --git a/tests/scf/test_gto2sto_fit.py b/tests/scf/test_gto2sto_fit.py
index 8aea1c78..9392faa0 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -5,13 +5,16 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-class TestGTO2STOFit(unittest.TestCase):
 
+class TestGTO2STOFit(unittest.TestCase):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -19,33 +22,39 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='C 0 0 0',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
+            atom="C 0 0 0",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
-        self.wf = SlaterJastrow(mol, kinetic='auto',
-                                configs='ground_state').gto2sto()
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.pos = -0.25 + 0.5 * \
-            torch.as_tensor(np.random.rand(10, 18))
+        self.wf = SlaterJastrow(
+            mol, kinetic="auto", configs="ground_state", jastrow=jastrow
+        ).gto2sto()
+
+        self.pos = -0.25 + 0.5 * torch.as_tensor(np.random.rand(10, 18))
         self.pos.requires_grad = True
 
     def test_forward(self):
-
         wfvals = self.wf(self.pos)
-        ref = torch.as_tensor([[-8.4430e-06],
-                               [1.5092e-02],
-                               [3.3809e-03],
-                               [9.7981e-03],
-                               [-6.8513e-02],
-                               [-4.6836e-03],
-                               [-3.2847e-04],
-                               [2.3636e-02],
-                               [5.5934e-04],
-                               [1.3205e-02]])
-        assert torch.allclose(wfvals.data, ref, rtol=1E-4, atol=1E-4)
+        ref = torch.as_tensor(
+            [
+                [-8.4430e-06],
+                [1.5092e-02],
+                [3.3809e-03],
+                [9.7981e-03],
+                [-6.8513e-02],
+                [-4.6836e-03],
+                [-3.2847e-04],
+                [2.3636e-02],
+                [5.5934e-04],
+                [1.3205e-02],
+            ]
+        )
+        assert torch.allclose(wfvals.data, ref, rtol=1e-4, atol=1e-4)
 
 
 if __name__ == "__main__":
diff --git a/tests/scf/test_molecule.py b/tests/scf/test_molecule.py
index 6ae26223..b6608952 100644
--- a/tests/scf/test_molecule.py
+++ b/tests/scf/test_molecule.py
@@ -4,52 +4,49 @@
 
 
 class TestMolecule(unittest.TestCase):
-
     def test1_create(self):
-
         # molecule
         mol = Molecule(
-            atom='H 0. 0. 0.; H 0. 0. 1.',
-            unit='bohr',
-            scf='hf',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
+            atom="H 0. 0. 0.; H 0. 0. 1.",
+            unit="bohr",
+            scf="hf",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         mol.print_total_energy()
 
     def test2_load(self):
-        mol = Molecule(load='H2_pyscf_sto-3g.hdf5')
+        _ = Molecule(load="H2_pyscf_sto-3g.hdf5")
 
     def test3_domain(self):
-        mol = Molecule(load='H2_pyscf_sto-3g.hdf5')
+        mol = Molecule(load="H2_pyscf_sto-3g.hdf5")
 
-        domain_center = mol.domain('center')
-        assert (domain_center['center'] ==
-                np.array([0., 0., 0.5])).all()
+        domain_center = mol.domain("center")
+        assert (domain_center["center"] == np.array([0.0, 0.0, 0.5])).all()
 
-        domain_uniform = mol.domain('uniform')
-        assert domain_uniform == {
-            'method': 'uniform', 'min': -0.5, 'max': 1.5}
+        domain_uniform = mol.domain("uniform")
+        assert domain_uniform == {"method": "uniform", "min": -0.5, "max": 1.5}
 
-        domain_normal = mol.domain('normal')
-        assert np.all(domain_normal['mean']
-                      == np.array([0., 0., 0.5]))
+        domain_normal = mol.domain("normal")
+        assert np.all(domain_normal["mean"] == np.array([0.0, 0.0, 0.5]))
 
-        domain_atomic = mol.domain('atomic')
-        assert np.all(domain_atomic['atom_coords'] == np.array([[0., 0., 0.],
-                                                                [0., 0., 1.]]))
+        domain_atomic = mol.domain("atomic")
+        assert np.all(
+            domain_atomic["atom_coords"] == np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
+        )
 
     def test4_create_dft(self):
-
         # molecule
         mol = Molecule(
-            atom='H 0. 0. 0.; H 0. 0. 1.',
-            unit='bohr',
-            calculator='pyscf',
-            scf='dft',
-            basis='sto-3g',
-            redo_scf=True)
+            atom="H 0. 0. 0.; H 0. 0. 1.",
+            unit="bohr",
+            calculator="pyscf",
+            scf="dft",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         mol.print_total_energy()
 
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
new file mode 100644
index 00000000..6611f02c
--- /dev/null
+++ b/tests/solver/test_base_solver.py
@@ -0,0 +1,50 @@
+import unittest
+import numpy as np
+
+class BaseTestSolvers:
+    class BaseTestSolverMolecule(unittest.TestCase):
+        def setUp(self):
+            self.mol = None
+            self.wf = None
+            self.sampler = None
+            self.opt = None
+            self.solver = None
+            self.pos = None
+            self.expected_energy = None
+            self.expected_variance = None
+
+        def test1_single_point(self):
+            """
+            Test the single point calculation of the solver. The calculation is run two times. 
+            The first time, the calculation is run with all the walkers and the 
+            second time with half of the walkers.
+            """
+            self.solver.single_point()
+            batchsize = int(self.solver.sampler.walkers.nwalkers/2) 
+            self.solver.single_point(batchsize=batchsize)
+
+        def test2_wf_opt_grad_auto(self):
+            """
+            Test the optimization of the wave function using autograd.
+            The optimization is run for 5 epochs with all the walkers and then 
+            for 5 epochs with half the walkers.
+            """
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="auto"
+            )
+            _ = self.solver.run(5)
+            batchsize = int(self.solver.sampler.walkers.nwalkers/2) 
+            _ = self.solver.run(5, batchsize=batchsize)
+
+        def test3_wf_opt_grad_manual(self):
+            """
+            Test the optimization of the wave function using manual gradients.
+            The optimization is run for 5 epochs with all the walkers and then 
+            for 5 epochs with half the walkers.
+            """
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="manual"
+            )
+            _ = self.solver.run(5)
+            batchsize = int(self.solver.sampler.walkers.nwalkers/2) 
+            _ = self.solver.run(5, batchsize=batchsize)
diff --git a/tests/solver/test_h2.py b/tests/solver/test_h2.py
deleted file mode 100644
index 489881ed..00000000
--- a/tests/solver/test_h2.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-from qmctorch.sampler import Hamiltonian, Metropolis
-from qmctorch.solver import Solver
-from qmctorch.utils import (plot_block, plot_blocking_energy,
-                            plot_correlation_coefficient, plot_energy,
-                            plot_integrated_autocorrelation_time,
-                            plot_walkers_traj)
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
-__PLOT__ = True
-
-
-class TestH2(unittest.TestCase):
-
-    def setUp(self):
-
-        torch.manual_seed(0)
-        np.random.seed(0)
-
-        # optimal parameters
-        self.opt_r = 0.69  # the two h are at +0.69 and -0.69
-        self.opt_sigma = 1.24
-
-        # molecule
-        self.mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
-
-        # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='auto',
-                                configs='single(2,2)')
-
-        # sampler
-        self.sampler = Metropolis(
-            nwalkers=1000,
-            nstep=2000,
-            step_size=0.5,
-            ndim=self.wf.ndim,
-            nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
-
-        self.hmc_sampler = Hamiltonian(
-            nwalkers=100,
-            nstep=200,
-            step_size=0.1,
-            ndim=self.wf.ndim,
-            nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
-
-        # optimizer
-        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
-
-        # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-        # ground state energy
-        self.ground_state_energy = -1.16
-
-        # ground state pos
-        self.ground_state_pos = 0.69
-
-    def test1_single_point(self):
-
-        self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
-        self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
-        self.solver.sampler = self.sampler
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-        # values on different arch
-        expected_energy = [-1.1464850902557373,
-                           -1.14937478612449]
-
-        # values on different arch
-        expected_variance = [0.9279592633247375,
-                             0.7445300449383236]
-
-        assert(np.any(np.isclose(e.data.item(), np.array(expected_energy))))
-        assert(np.any(np.isclose(v.data.item(), np.array(expected_variance))))
-
-    def test2_single_point_hmc(self):
-
-        self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
-        self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
-        self.solver.sampler = self.hmc_sampler
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-        # values on different arch
-        expected_energy = [-1.0877732038497925,
-                           -1.088576]
-
-        # values on different arch
-        expected_variance = [0.14341972768306732,
-                             0.163771]
-
-        assert(np.any(np.isclose(e.data.item(), np.array(expected_energy))))
-        assert(np.any(np.isclose(v.data.item(), np.array(expected_variance))))
-
-    def test3_wf_opt(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-        if __PLOT__:
-            plot_energy(obs.local_energy, e0=-
-                        1.1645, show_variance=True)
-
-    def test4_geo_opt(self):
-
-        self.solver.wf.ao.atom_coords[0,
-                                      2].data = torch.as_tensor(-0.37)
-        self.solver.wf.ao.atom_coords[1,
-                                      2].data = torch.as_tensor(0.37)
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        self.solver.geo_opt(5, nepoch_wf_init=10, nepoch_wf_update=5)
-
-        # load the best model
-        self.solver.wf.load(self.solver.hdf5file, 'geo_opt')
-        self.solver.wf.eval()
-
-        # sample and compute variables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-        e = e.data.numpy()
-        v = v.data.numpy()
-
-        # it might be too much to assert with the ground state energy
-        assert(e > 2 * self.ground_state_energy and e < 0.)
-        assert(v > 0 and v < 2.)
-
-    def test5_sampling_traj(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.sampler.nstep = 100
-        self.solver.sampler.ntherm = 0
-        self.solver.sampler.ndecor = 1
-
-        pos = self.solver.sampler(self.solver.wf.pdf)
-        obs = self.solver.sampling_traj(pos)
-
-        if __PLOT__:
-            plot_walkers_traj(obs.local_energy)
-            plot_block(obs.local_energy)
-
-            plot_blocking_energy(obs.local_energy, block_size=10)
-            plot_correlation_coefficient(obs.local_energy)
-            plot_integrated_autocorrelation_time(obs.local_energy)
-
-
-if __name__ == "__main__":
-    # unittest.main()
-    t = TestH2()
-    t.setUp()
-    # t.test2_single_point_hmc()
-    # t.test1_single_point()
-    t.test3_wf_opt()
-    # t.test5_sampling_traj()
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index 6f20f90b..1711ec96 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -1,31 +1,32 @@
-import unittest
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.scf import Molecule
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
 
-import numpy as np
+import unittest
 import torch
 import torch.optim as optim
 
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import Solver
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
+from .test_base_solver import BaseTestSolvers
 from ..path_utils import PATH_TEST
 
 
-class TestH2ADF(unittest.TestCase):
-
+class TestH2ADF(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
 
         # molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/H2_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/H2_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='auto',
-                                configs='single(2,2)')
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -34,57 +35,20 @@ def setUp(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-        # ground state energy
-        self.ground_state_energy = -1.16
-
-        # ground state pos
-        self.ground_state_pos = 0.69
-
-    def test_single_point(self):
-
-        self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
-        self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
-        self.solver.sampler = self.sampler
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        expected_energy = [-1.1572532653808594,
-                           -1.1501641653648578]
-
-        expected_variance = [0.05085879936814308,
-                             0.05094174843043177]
-
-        assert(np.any(np.isclose(e.data.item(), np.array(expected_energy))))
-        assert(np.any(np.isclose(v.data.item(), np.array(expected_variance))))
-
-        # assert(e > 2 * self.ground_state_energy and e < 0.)
-        # assert(v > 0 and v < 5.)
-
-    def test_wf_opt_auto_grad(self):
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
+        self.expected_energy = [-1.1572532653808594, -1.1501641653648578]
 
-    def test_wf_opt_manual_grad(self):
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
+        self.expected_variance = [0.05085879936814308, 0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_adf_jacobi.py b/tests/solver/test_h2_adf_jacobi.py
index 97dbfdc4..0d9e4c35 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -1,30 +1,31 @@
 import unittest
 
-import numpy as np
 import torch
 import torch.optim as optim
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from ..path_utils import PATH_TEST
+from .test_base_solver import BaseTestSolvers
 
 
-class TestH2ADFJacobi(unittest.TestCase):
-
+class TestH2ADFJacobi(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
 
         # molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/H2_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/H2_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)')
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -33,56 +34,20 @@ def setUp(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-        # ground state energy
-        self.ground_state_energy = -1.16
-
-        # ground state pos
-        self.ground_state_pos = 0.69
-
-    def test_single_point(self):
-
-        self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
-        self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
-        self.solver.sampler = self.sampler
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-        print(e.data.item(), v.data.item())
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        expected_energy = [-1.1571345329284668,
-                           -1.1501641653648578]
-
-        expected_variance = [0.05087674409151077,
-                             0.05094174843043177]
-
-        assert(np.any(np.isclose(e.data.item(), np.array(expected_energy))))
-        assert(np.any(np.isclose(v.data.item(), np.array(expected_variance))))
-
-    def test_wf_opt_auto_grad(self):
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test_wf_opt_manual_grad(self):
+        self.expected_energy = [-1.1571345329284668, -1.1501641653648578]
 
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
+        self.expected_variance = [0.05087674409151077, 0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_correlated.py b/tests/solver/test_h2_correlated.py
deleted file mode 100644
index f5aa89dc..00000000
--- a/tests/solver/test_h2_correlated.py
+++ /dev/null
@@ -1,142 +0,0 @@
-
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import Solver
-from qmctorch.utils import plot_energy
-
-
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
-__PLOT__ = False
-
-
-class TestH2Correlated(unittest.TestCase):
-
-    def setUp(self):
-
-        torch.manual_seed(0)
-        np.random.seed(0)
-        set_torch_double_precision()
-
-        # optimal parameters
-        self.opt_r = 0.69  # the two h are at +0.69 and -0.69
-        self.opt_sigma = 1.24
-
-        # molecule
-        self.mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
-
-        # wave function
-        self.wf = SlaterOrbitalDependentJastrow(self.mol,
-                                                kinetic='auto',
-                                                configs='cas(2,2)',
-                                                jastrow_kernel=FullyConnectedJastrowKernel,
-                                                include_all_mo=True)
-
-        # sampler
-        self.sampler = Metropolis(
-            nwalkers=1000,
-            nstep=2000,
-            step_size=0.5,
-            ndim=self.wf.ndim,
-            nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
-
-        # optimizer
-        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
-
-        # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-        # ground state energy
-        self.ground_state_energy = -1.16
-
-        # ground state pos
-        self.ground_state_pos = 0.69
-
-    def test_0_wavefunction(self):
-
-        # artificial pos
-        self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
-        self.pos.requires_grad = True
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
-        self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
-        self.solver.sampler = self.sampler
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    def test3_wf_opt(self):
-        self.solver.sampler = self.sampler
-        self.solver.configure(
-            track=['local_energy', 'parameters'], loss='energy', grad='auto')
-        obs = self.solver.run(5)
-        if __PLOT__:
-            plot_energy(obs.local_energy, e0=-
-                        1.1645, show_variance=True)
-
-    def test4_geo_opt(self):
-
-        self.solver.wf.ao.atom_coords[0,
-                                      2].data = torch.as_tensor(-0.37)
-        self.solver.wf.ao.atom_coords[1,
-                                      2].data = torch.as_tensor(0.37)
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        self.solver.geo_opt(5, nepoch_wf_init=10, nepoch_wf_update=5,
-                            hdf5_group='geo_opt_correlated')
-
-        # load the best model
-        self.solver.wf.load(self.solver.hdf5file,
-                            'geo_opt_correlated')
-        self.solver.wf.eval()
-
-        # sample and compute variables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-        e = e.data.numpy()
-        v = v.data.numpy()
-
-        # it might be too much to assert with the ground state energy
-        assert(e > 2 * self.ground_state_energy and e < 0.)
-        assert(v > 0 and v < 2.)
-
-
-if __name__ == "__main__":
-    # unittest.main()
-    t = TestH2Correlated()
-    t.setUp()
-    # t.test_0_wavefunction()
-    # t.test1_single_point()
-    # t.test2_single_point_hmc()
-    t.test3_wf_opt()
-    # t.test5_sampling_traj()
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
new file mode 100644
index 00000000..3c20711f
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -0,0 +1,67 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+from .test_base_solver import BaseTestSolvers
+
+from qmctorch.sampler import Hamiltonian
+from qmctorch.solver import Solver
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+__PLOT__ = True
+
+
+class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        # optimal parameters
+        self.opt_r = 0.69  # the two h are at +0.69 and -0.69
+        self.opt_sigma = 1.24
+
+        # molecule
+        self.mol = Molecule(
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # wave function
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
+
+        self.sampler = Hamiltonian(
+            nwalkers=100,
+            nstep=200,
+            step_size=0.1,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+        )
+
+        # optimizer
+        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
+
+        # solver
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
+
+        # values on different arch
+        self.expected_energy = [-1.0877732038497925, -1.088576]
+
+        # values on different arch
+        self.expected_variance = [0.14341972768306732, 0.163771]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
new file mode 100644
index 00000000..f7702dc8
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -0,0 +1,67 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+from .test_base_solver import BaseTestSolvers
+
+from qmctorch.sampler import Hamiltonian
+from qmctorch.solver import Solver
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+__PLOT__ = True
+
+
+class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        # optimal parameters
+        self.opt_r = 0.69  # the two h are at +0.69 and -0.69
+        self.opt_sigma = 1.24
+
+        # molecule
+        self.mol = Molecule(
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # wave function
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
+
+        self.sampler = Hamiltonian(
+            nwalkers=100,
+            nstep=200,
+            step_size=0.1,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+        )
+
+        # optimizer
+        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
+
+        # solver
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
+
+        # values on different arch
+        self.expected_energy = [-1.0877732038497925, -1.088576]
+
+        # values on different arch
+        self.expected_variance = [0.14341972768306732, 0.163771]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
new file mode 100644
index 00000000..b6c1dcc9
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -0,0 +1,75 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+from .test_base_solver import BaseTestSolvers
+
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+__PLOT__ = True
+
+
+class TestH2SamplerMH(BaseTestSolvers.BaseTestSolverMolecule):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        # optimal parameters
+        self.opt_r = 0.69  # the two h are at +0.69 and -0.69
+        self.opt_sigma = 1.24
+
+        # molecule
+        self.mol = Molecule(
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # wave function
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
+
+        # sampler
+        self.sampler = Metropolis(
+            nwalkers=1000,
+            nstep=2000,
+            step_size=0.5,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
+
+        # optimizer
+        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
+
+        # solver
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
+
+        # values on different arch
+        self.expected_energy = [-1.1464850902557373, -1.14937478612449]
+
+        # values on different arch
+        self.expected_variance = [0.9279592633247375, 0.7445300449383236]
+
+
+if __name__ == "__main__":
+    unittest.main()
+    t = TestH2SamplerMH()
+    t.setUp()
+    # # t.test2_single_point_hmc()
+    t.test1_single_point()
+    # t.test3_wf_opt()
+    # # t.test5_sampling_traj()
diff --git a/tests/solver/test_h2_stats.py b/tests/solver/test_h2_pyscf_stats.py
similarity index 56%
rename from tests/solver/test_h2_stats.py
rename to tests/solver/test_h2_pyscf_stats.py
index 0dcc729a..1cecf465 100644
--- a/tests/solver/test_h2_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,21 +6,20 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
-from qmctorch.utils import (plot_block, plot_blocking_energy,
-                            plot_correlation_coefficient,
-                            plot_integrated_autocorrelation_time,
-                            plot_walkers_traj)
+from qmctorch.utils.plot_data import (
+    plot_block,
+    plot_blocking_energy,
+    plot_correlation_coefficient,
+    plot_integrated_autocorrelation_time,
+    plot_walkers_traj,
+)
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
-
-__PLOT__ = False
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 
 class TestH2Stat(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -30,14 +29,19 @@ def setUp(self):
 
         # molecule
         self.mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)')
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -48,20 +52,17 @@ def setUp(self):
             nelec=self.wf.nelec,
             ntherm=0,
             ndecor=1,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
     def test_sampling_traj(self):
-
         pos = self.solver.sampler(self.solver.wf.pdf)
         obs = self.solver.sampling_traj(pos)
 
@@ -69,14 +70,12 @@ def test_sampling_traj(self):
         plot_block(obs.local_energy)
 
     def test_stat(self):
-
         pos = self.solver.sampler(self.solver.wf.pdf)
         obs = self.solver.sampling_traj(pos)
 
-        if __PLOT__:
-            plot_blocking_energy(obs.local_energy, block_size=10)
-            plot_correlation_coefficient(obs.local_energy)
-            plot_integrated_autocorrelation_time(obs.local_energy)
+        plot_blocking_energy(obs.local_energy, block_size=10)
+        plot_correlation_coefficient(obs.local_energy)
+        plot_integrated_autocorrelation_time(obs.local_energy)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih.py b/tests/solver/test_lih.py
deleted file mode 100644
index e110d08f..00000000
--- a/tests/solver/test_lih.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import Solver
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
-
-class TestLiH(unittest.TestCase):
-
-    def setUp(self):
-
-        torch.manual_seed(0)
-        np.random.seed(0)
-
-        # molecule
-        self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
-
-        # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)',
-                                include_all_mo=False)
-
-        # sampler
-        self.sampler = Metropolis(
-            nwalkers=500,
-            nstep=200,
-            step_size=0.05,
-            ndim=self.wf.ndim,
-            nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
-
-        # optimizer
-        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
-
-        # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-        # # values on different arch
-        # expected_energy = [-1.1464850902557373,
-        #                    -1.14937478612449]
-
-        # # values on different arch
-        # expected_variance = [0.9279592633247375,
-        #                      0.7445300449383236]
-
-        # assert(np.any(np.isclose(e.data.item(), np.array(expected_energy))))
-        # assert(np.any(np.isclose(v.data.item(), np.array(expected_variance))))
-
-    def test2_wf_opt_grad_auto(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
-
-if __name__ == "__main__":
-    unittest.main()
-    # t = TestLiH()
-    # t.setUp()
-    # t.test1_single_point()
-    # t.test2_wf_opt_grad_auto()
-    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index bac07df2..606ed2b4 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -7,37 +7,53 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
 from ..path_utils import PATH_TEST
+from .test_base_solver import BaseTestSolvers
 
 
-class TestLiHBackFlowADF(unittest.TestCase):
-
+class TestLiHBackFlowADF(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
         set_torch_double_precision()
 
         # molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/LiH_adf_dz.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/LiH_adf_dz.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # backflow
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
+
         # wave function
-        self.wf = SlaterJastrowBackFlow(self.mol, kinetic='jacobi',
-                                        configs='single_double(2,2)',
-                                        orbital_dependent_backflow=True,
-                                        include_all_mo=True)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            jastrow=jastrow,
+            backflow=backflow,
+            configs="single_double(2,2)",
+            include_all_mo=True,
+        )
 
         # fc weights
         self.wf.fc.weight.data = torch.rand(self.wf.fc.weight.shape)
 
         # jastrow weights
         self.wf.jastrow.jastrow_kernel.weight.data = torch.rand(
-            self.wf.jastrow.jastrow_kernel.weight.shape)
+            self.wf.jastrow.jastrow_kernel.weight.shape
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -46,55 +62,21 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_0_wavefunction(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    def test2_wf_opt_grad_auto(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestLiHBackFlowADF()
-    t.setUp()
-    t.test2_wf_opt_grad_auto()
+    unittest.main()
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index 5ceceafc..187325a1 100644
--- a/tests/solver/test_lih_correlated.py
+++ b/tests/solver/test_lih_correlated.py
@@ -14,23 +14,19 @@
 
 
 class TestLiHCorrelated(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
         set_torch_double_precision()
 
         # molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/LiH_adf_dz.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/LiH_adf_dz.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
         # wave function
-        self.wf = SlaterOrbitalDependentJastrow(self.mol,
-                                                kinetic='jacobi',
-                                                configs='cas(2,2)',
-                                                include_all_mo=True)
+        self.wf = SlaterOrbitalDependentJastrow(
+            self.mol, kinetic="jacobi", configs="cas(2,2)", include_all_mo=True
+        )
 
         # fc weights
         self.wf.fc.weight.data = torch.rand(self.wf.fc.weight.shape)
@@ -46,35 +42,28 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf,
-                                          sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
     def test_0_wavefunction(self):
-
         eauto = self.wf.kinetic_energy_autograd(self.pos)
         ejac = self.wf.kinetic_energy_jacobi(self.pos)
 
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(eauto.data, ejac.data, rtol=1e-4, atol=1e-4)
 
     def test1_single_point(self):
-
         # sample and compute observables
         obs = self.solver.single_point()
         _, _ = obs.energy, obs.variance
@@ -89,9 +78,8 @@ def test1_single_point(self):
     def test3_wf_opt_grad_manual(self):
         self.solver.sampler = self.sampler
 
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
+        self.solver.configure(track=["local_energy"], loss="energy", grad="manual")
+        _ = self.solver.run(5)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_generic_jastrow.py b/tests/solver/test_lih_generic_jastrow.py
deleted file mode 100644
index 25ffd51c..00000000
--- a/tests/solver/test_lih_generic_jastrow.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import Solver
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
-from qmctorch.utils import set_torch_double_precision
-
-
-class TestLiH(unittest.TestCase):
-
-    def setUp(self):
-
-        torch.manual_seed(0)
-        np.random.seed(0)
-        set_torch_double_precision()
-
-        # molecule
-        self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
-
-        # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow_kernel=FullyConnectedJastrowKernel,
-                                configs='single(2,2)',
-                                include_all_mo=False)
-
-        # sampler
-        self.sampler = Metropolis(
-            nwalkers=500,
-            nstep=200,
-            step_size=0.05,
-            ndim=self.wf.ndim,
-            nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
-
-        # optimizer
-        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
-
-        # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
-
-        # artificial pos
-        self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
-        self.pos.requires_grad = True
-
-    def test_0_wavefunction(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    # def test2_wf_opt_grad_auto(self):
-    #     self.solver.sampler = self.sampler
-
-    #     self.solver.configure(track=['local_energy'],
-    #                           loss='energy', grad='auto')
-    #     obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
-
-if __name__ == "__main__":
-    unittest.main()
-    # t = TestLiH()
-    # t.setUp()
-    # t.test1_single_point()
-    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_pyscf.py b/tests/solver/test_lih_pyscf.py
new file mode 100644
index 00000000..20be58b7
--- /dev/null
+++ b/tests/solver/test_lih_pyscf.py
@@ -0,0 +1,65 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+from .test_base_solver import BaseTestSolvers
+
+
+class TestLiH(BaseTestSolvers.BaseTestSolverMolecule):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        # molecule
+        self.mol = Molecule(
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # wave function
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
+
+        # sampler
+        self.sampler = Metropolis(
+            nwalkers=500,
+            nstep=200,
+            step_size=0.05,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
+
+        # optimizer
+        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
+
+        # solver
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
+
+
+if __name__ == "__main__":
+    unittest.main()
+    # t = TestLiH()
+    # t.setUp()
+    # t.test1_single_point()
+    # t.test2_wf_opt_grad_auto()
+    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 13d028c8..fe15c965 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -1,4 +1,3 @@
-from tests.wavefunction.test_slaterjastrow import TestSlaterJastrow
 import unittest
 
 import numpy as np
@@ -8,37 +7,56 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
+from .test_base_solver import BaseTestSolvers
 
-class TestLiHBackFlowPySCF(unittest.TestCase):
 
+class TestLiHBackFlowPySCF(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
         set_torch_double_precision()
 
         # molecule
         self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # backflow
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrowBackFlow(self.mol, kinetic='jacobi',
-                                        configs='single_double(2,2)',
-                                        orbital_dependent_backflow=False,
-                                        include_all_mo=True)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            jastrow=jastrow,
+            backflow=backflow,
+            configs="single_double(2,2)",
+            include_all_mo=True,
+        )
 
         # fc weights
         self.wf.fc.weight.data = torch.rand(self.wf.fc.weight.shape)
 
         # jastrow weights
         self.wf.jastrow.jastrow_kernel.weight.data = torch.rand(
-            self.wf.jastrow.jastrow_kernel.weight.shape)
+            self.wf.jastrow.jastrow_kernel.weight.shape
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -47,55 +65,24 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_0_wavefunction(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    def test2_wf_opt_grad_auto(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestLiHBackFlowPySCF()
-    t.setUp()
-    t.test3_wf_opt_grad_manual()
+    unittest.main()
+    # t = TestLiHBackFlowPySCF()
+    # t.setUp()
+    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index 68fc5fca..0ce23238 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -1,4 +1,3 @@
-from tests.wavefunction.test_slaterjastrow import TestSlaterJastrow
 import unittest
 
 import numpy as np
@@ -8,7 +7,12 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow, SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.utils import set_torch_double_precision
 
 
@@ -18,39 +22,58 @@ def reset_generator():
 
 
 class TestCompareLiHBackFlowPySCF(unittest.TestCase):
-
     def setUp(self):
-
         set_torch_double_precision()
         reset_generator()
 
         # molecule
         self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
 
         # molecule
         self.mol_ref = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # backflow
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # backflow wave function
-        self.wf = SlaterJastrowBackFlow(self.mol,
-                                        kinetic='jacobi',
-                                        configs='single_double(2,2)',
-                                        include_all_mo=True)
-        self.wf.ao.backflow_trans.backflow_kernel.weight.data *= 0.
+        self.wf = SlaterJastrow(
+            self.mol,
+            jastrow=jastrow,
+            backflow=backflow,
+            kinetic="jacobi",
+            configs="single_double(2,2)",
+            include_all_mo=True,
+        )
+        self.wf.ao.backflow_trans.backflow_kernel.weight.data *= 0.0
         self.wf.ao.backflow_trans.backflow_kernel.weight.requires_grad = False
 
+        # jastrow
+        jastrow_ref = JastrowFactor(self.mol, PadeJastrowKernel)
+
         # normal wave function
-        self.wf_ref = SlaterJastrow(self.mol_ref,
-                                    kinetic='jacobi',
-                                    include_all_mo=True,
-                                    configs='single_double(2,2)')
+        self.wf_ref = SlaterJastrow(
+            self.mol_ref,
+            jastrow=jastrow_ref,
+            backflow=None,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+        )
 
         # fc weights
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
@@ -59,10 +82,13 @@ def setUp(self):
 
         # jastrow weights
         self.random_jastrow_weight = torch.rand(
-            self.wf.jastrow.jastrow_kernel.weight.shape)
+            self.wf.jastrow.jastrow_kernel.weight.shape
+        )
 
         self.wf.jastrow.jastrow_kernel.weight.data = self.random_jastrow_weight.clone()
-        self.wf_ref.jastrow.jastrow_kernel.weight.data = self.random_jastrow_weight.clone()
+        self.wf_ref.jastrow.jastrow_kernel.weight.data = (
+            self.random_jastrow_weight.clone()
+        )
 
         reset_generator()
         # sampler
@@ -72,10 +98,9 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         reset_generator()
         self.sampler_ref = Metropolis(
@@ -84,10 +109,9 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         reset_generator()
@@ -97,20 +121,18 @@ def setUp(self):
         self.opt_ref = optim.Adam(self.wf_ref.parameters(), lr=0.01)
 
         # solver
-        self.solver_ref = Solver(wf=self.wf_ref, sampler=self.sampler_ref,
-                                              optimizer=self.opt_ref)
+        self.solver_ref = Solver(
+            wf=self.wf_ref, sampler=self.sampler_ref, optimizer=self.opt_ref
+        )
 
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
     def test_0_wavefunction(self):
-
         # compute the kinetic energy using bf orb
         reset_generator()
         e_bf = self.wf.kinetic_energy_jacobi(self.pos)
@@ -120,11 +142,9 @@ def test_0_wavefunction(self):
         e_ref = self.wf_ref.kinetic_energy_jacobi(self.pos)
 
         print(torch.stack([e_bf, e_ref], axis=1).squeeze())
-        assert torch.allclose(
-            e_bf.data, e_ref.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(e_bf.data, e_ref.data, rtol=1e-4, atol=1e-4)
 
     def test1_single_point(self):
-
         # sample and compute observables
         reset_generator()
         obs = self.solver.single_point()
@@ -142,58 +162,52 @@ def test1_single_point(self):
         e_ref, v_ref = obs_ref.energy, obs.variance
 
         # compare values
-        assert torch.allclose(
-            e_bf.data, e_ref.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(e_bf.data, e_ref.data, rtol=1e-4, atol=1e-4)
 
-        assert torch.allclose(
-            v_bf.data, v_ref.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(v_bf.data, v_ref.data, rtol=1e-4, atol=1e-4)
 
     def test2_wf_opt_grad_auto(self):
-
         nepoch = 5
 
         # optimize using backflow
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        self.solver.configure_resampling(mode='never')
+        self.solver.configure(track=["local_energy"], loss="energy", grad="auto")
+        self.solver.configure_resampling(mode="never")
 
         reset_generator()
         obs = self.solver.run(nepoch)
         e_bf = torch.as_tensor(np.array(obs.energy))
 
         # optimize using ref
-        self.solver_ref.configure(track=['local_energy'],
-                                  loss='energy', grad='auto')
-        self.solver_ref.configure_resampling(mode='never')
+        self.solver_ref.configure(track=["local_energy"], loss="energy", grad="auto")
+        self.solver_ref.configure_resampling(mode="never")
 
         reset_generator()
         obs_ref = self.solver_ref.run(nepoch)
         e_ref = torch.as_tensor(np.array(obs_ref.energy))
 
-        assert torch.allclose(
-            e_bf, e_ref, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(e_bf, e_ref, rtol=1e-4, atol=1e-4)
 
     def test3_wf_opt_grad_manual(self):
-
         nepoch = 5
 
         # optimize using backflow
         reset_generator()
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='manual')
+        self.solver.configure(
+            track=["local_energy", "parameters"], loss="energy", grad="manual"
+        )
         obs = self.solver.run(nepoch)
         e_bf = torch.as_tensor(np.array(obs.energy))
 
         # optimize using backflow
         reset_generator()
-        self.solver_ref.configure(track=['local_energy', 'parameters'],
-                                  loss='energy', grad='manual')
+        self.solver_ref.configure(
+            track=["local_energy", "parameters"], loss="energy", grad="manual"
+        )
         obs = self.solver_ref.run(nepoch)
         e_ref = torch.as_tensor(np.array(obs.energy))
 
         # compare values
-        assert torch.allclose(
-            e_bf, e_ref, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(e_bf, e_ref, rtol=1e-4, atol=1e-4)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_pyscf_generic_backflow.py b/tests/solver/test_lih_pyscf_generic_backflow.py
index f544175b..89a67a31 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -1,4 +1,3 @@
-from tests.wavefunction.test_slaterjastrow import TestSlaterJastrow
 import unittest
 
 import numpy as np
@@ -8,39 +7,56 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelPowerSum,
+)
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelPowerSum
 
+from .test_base_solver import BaseTestSolvers
 
-class TestLiHBackFlowPySCF(unittest.TestCase):
 
+class TestLiHBackFlowPySCF(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
         set_torch_double_precision()
 
         # molecule
         self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # backflow
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelPowerSum, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrowBackFlow(self.mol, kinetic='jacobi',
-                                        configs='single_double(2,2)',
-                                        backflow_kernel=BackFlowKernelPowerSum,
-                                        orbital_dependent_backflow=False,
-                                        include_all_mo=True)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            jastrow=jastrow,
+            backflow=backflow,
+            configs="single_double(2,2)",
+            include_all_mo=True,
+        )
 
         # fc weights
         self.wf.fc.weight.data = torch.rand(self.wf.fc.weight.shape)
 
         # jastrow weights
         self.wf.jastrow.jastrow_kernel.weight.data = torch.rand(
-            self.wf.jastrow.jastrow_kernel.weight.shape)
+            self.wf.jastrow.jastrow_kernel.weight.shape
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -49,57 +65,24 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_0_wavefunction(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    def test2_wf_opt_grad_auto(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
 
 if __name__ == "__main__":
     unittest.main()
     # t = TestLiHBackFlowPySCF()
     # t.setUp()
-    # t.test_0_wavefunction()
-    # t.test1_single_point()
-    # # t.test3_wf_opt_grad_manual()
+    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_pyscf_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
new file mode 100644
index 00000000..c43e3564
--- /dev/null
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -0,0 +1,77 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import Solver
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import (
+    JastrowFactor,
+    FullyConnectedJastrowKernel,
+)
+
+from qmctorch.utils import set_torch_double_precision
+from .test_base_solver import BaseTestSolvers
+
+
+class TestLiH(BaseTestSolvers.BaseTestSolverMolecule):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+        set_torch_double_precision()
+
+        # molecule
+        self.mol = Molecule(
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, FullyConnectedJastrowKernel)
+
+        # wave function
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
+
+        # sampler
+        self.sampler = Metropolis(
+            nwalkers=500,
+            nstep=200,
+            step_size=0.05,
+            ndim=self.wf.ndim,
+            nelec=self.wf.nelec,
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
+
+        # optimizer
+        self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
+
+        # solver
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
+
+        # artificial pos
+        self.nbatch = 10
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
+        self.pos.requires_grad = True
+
+    def test2_wf_opt_grad_auto(self):
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()
+    # t = TestLiH()
+    # t.setUp()
+    # t.test1_single_point()
+    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 88220efd..3bdd156f 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -1,4 +1,3 @@
-from tests.wavefunction.test_slaterjastrow import TestSlaterJastrow
 import unittest
 
 import numpy as np
@@ -8,37 +7,56 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
+from .test_base_solver import BaseTestSolvers
 
-class TestLiHBackFlowPySCF(unittest.TestCase):
 
+class TestLiHBackFlowPySCF(BaseTestSolvers.BaseTestSolverMolecule):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
         set_torch_double_precision()
 
         # molecule
         self.mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
+
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        # backflow
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # wave function
-        self.wf = SlaterJastrowBackFlow(self.mol, kinetic='jacobi',
-                                        configs='single_double(2,2)',
-                                        orbital_dependent_backflow=True,
-                                        include_all_mo=True)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            jastrow=jastrow,
+            backflow=backflow,
+            configs="single_double(2,2)",
+            include_all_mo=True,
+        )
 
         # fc weights
         self.wf.fc.weight.data = torch.rand(self.wf.fc.weight.shape)
 
         # jastrow weights
         self.wf.jastrow.jastrow_kernel.weight.data = torch.rand(
-            self.wf.jastrow.jastrow_kernel.weight.shape)
+            self.wf.jastrow.jastrow_kernel.weight.shape
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -47,55 +65,24 @@ def setUp(self):
             step_size=0.05,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("normal"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = Solver(wf=self.wf, sampler=self.sampler,
-                                          optimizer=self.opt)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # artificial pos
         self.nbatch = 10
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.pos = torch.as_tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_0_wavefunction(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-        print(torch.stack([eauto, ejac], axis=1).squeeze())
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test1_single_point(self):
-
-        # sample and compute observables
-        obs = self.solver.single_point()
-        e, v = obs.energy, obs.variance
-
-    def test2_wf_opt_grad_auto(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy'],
-                              loss='energy', grad='auto')
-        obs = self.solver.run(5)
-
-    def test3_wf_opt_grad_manual(self):
-        self.solver.sampler = self.sampler
-
-        self.solver.configure(track=['local_energy', 'parameters'],
-                              loss='energy', grad='manual')
-        obs = self.solver.run(5)
-
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestLiHBackFlowPySCF()
-    t.setUp()
-    t.test3_wf_opt_grad_manual()
+    unittest.main()
+    # t = TestLiHBackFlowPySCF()
+    # t.setUp()
+    # t.test3_wf_opt_grad_manual()
diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 97025d95..30cf30f6 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -2,54 +2,54 @@
 
 import torch
 
-from qmctorch.utils import (InterpolateAtomicOrbitals,
-                            InterpolateMolecularOrbitals)
+from qmctorch.utils import InterpolateAtomicOrbitals, InterpolateMolecularOrbitals
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-class TestInterpolate(unittest.TestCase):
 
+class TestInterpolate(unittest.TestCase):
     def setUp(self):
-
         # molecule
         self.mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='dzp')
+            atom="H 0 0 -0.69; H 0 0 0.69", unit="bohr", calculator="pyscf", basis="dzp"
+        )
+
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)')
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         npts = 51
         self.pos = torch.zeros(npts, 6)
         self.pos[:, 2] = torch.linspace(-2, 2, npts)
 
     def test_ao(self):
-
         interp_ao = InterpolateAtomicOrbitals(self.wf)
         inter = interp_ao(self.pos)
         ref = self.wf.ao(self.pos)
         delta = (inter - ref).abs().mean()
-        assert(delta < 0.1)
+        assert delta < 0.1
 
     def test_mo_reg(self):
-
         interp_mo = InterpolateMolecularOrbitals(self.wf)
-        inter = interp_mo(self.pos, method='reg')
-        ref = self.wf.mo(self.wf.mo_scf(self.wf.ao(self.pos)))
+        inter = interp_mo(self.pos, method="reg")
+        ref = self.wf.mo(self.wf.ao(self.pos))
         delta = (inter - ref).abs().mean()
-        assert(delta < 0.1)
+        assert delta < 0.1
 
     def test_mo_irreg(self):
-
         interp_mo = InterpolateMolecularOrbitals(self.wf)
-        inter = interp_mo(self.pos, method='irreg')
-        ref = self.wf.mo(self.wf.mo_scf(self.wf.ao(self.pos)))
+        inter = interp_mo(self.pos, method="irreg")
+        ref = self.wf.mo(self.wf.ao(self.pos))
         delta = (inter - ref).abs().mean()
-        assert(delta < 0.1)
+        assert delta < 0.1
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
new file mode 100644
index 00000000..7f7144b7
--- /dev/null
+++ b/tests/wavefunction/base_test_cases.py
@@ -0,0 +1,192 @@
+import unittest
+from torch.autograd import grad, gradcheck, Variable
+
+import torch
+
+
+def hess(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+
+    for idim in range(jacob.shape[1]):
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, idim] = tmp[:, idim]
+
+    return hess
+
+
+class BaseTestCases:
+    class WaveFunctionBaseTest(unittest.TestCase):
+        def setUp(self):
+            """Init the base test"""
+
+            def wf_placeholder(pos, **kwargs):
+                """Callable for wf"""
+                return None
+
+            self.pos = None
+            self.wf = wf_placeholder
+            self.nbatch = None
+
+        def test_forward(self):
+            """Test that the forward pass works"""
+            _ = self.wf(self.pos)
+
+        def test_antisymmetry(self):
+            """Test that the wf values are antisymmetric
+            wrt exchange of 2 electrons of same spin."""
+            wfvals_ref = self.wf(self.pos)
+
+            if self.wf.nelec < 4:
+                print(
+                    "Warning : antisymmetry cannot be tested with \
+                        only %d electrons"
+                    % self.wf.nelec
+                )
+                return
+
+            # test spin up
+            pos_xup = self.pos.clone()
+            perm_up = list(range(self.wf.nelec))
+            perm_up[0] = 1
+            perm_up[1] = 0
+            pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
+            pos_xup = pos_xup[:, perm_up, :].reshape(self.nbatch, self.wf.nelec * 3)
+
+            wfvals_xup = self.wf(pos_xup)
+            assert torch.allclose(wfvals_ref, -1 * wfvals_xup)
+
+            # test spin down
+            pos_xdn = self.pos.clone()
+            perm_dn = list(range(self.wf.nelec))
+            perm_dn[self.wf.mol.nup - 1] = self.wf.mol.nup
+            perm_dn[self.wf.mol.nup] = self.wf.mol.nup - 1
+            pos_xdn = pos_xdn.reshape(self.nbatch, self.wf.nelec, 3)
+            pos_xdn = pos_xdn[:, perm_up, :].reshape(self.nbatch, self.wf.nelec * 3)
+
+            wfvals_xdn = self.wf(pos_xdn)
+            assert torch.allclose(wfvals_ref, -1 * wfvals_xdn)
+
+        def test_grad_mo(self):
+            """Gradients of the MOs."""
+
+            mo = self.wf.pos2mo(self.pos)
+            dmo = self.wf.pos2mo(self.pos, derivative=1)
+
+            dmo_grad = grad(mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
+
+            gradcheck(self.wf.pos2mo, self.pos)
+
+            assert torch.allclose(dmo.sum(), dmo_grad.sum())
+            assert torch.allclose(
+                dmo.sum(-1), dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)
+            )
+
+        def test_hess_mo(self):
+            """Hessian of the MOs."""
+            val = self.wf.pos2mo(self.pos)
+
+            d2val_grad = hess(val, self.pos)
+            d2val = self.wf.pos2mo(self.pos, derivative=2)
+
+            assert torch.allclose(d2val.sum(), d2val_grad.sum())
+
+            assert torch.allclose(
+                d2val.sum(-1).sum(-1),
+                d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1).sum(-1),
+            )
+
+            assert torch.allclose(
+                d2val.sum(-1), d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)
+            )
+
+        def test_local_energy(self):
+            self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
+            eloc_auto = self.wf.local_energy(self.pos)
+
+            self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
+            eloc_jac = self.wf.local_energy(self.pos)
+
+            assert torch.allclose(eloc_auto.data, eloc_jac.data, rtol=1e-4, atol=1e-4)
+
+        def test_kinetic_energy(self):
+            eauto = self.wf.kinetic_energy_autograd(self.pos)
+            ejac = self.wf.kinetic_energy_jacobi(self.pos)
+
+            assert torch.allclose(eauto.data, ejac.data, rtol=1e-4, atol=1e-4)
+
+        def test_gradients_wf(self):
+            grads = self.wf.gradients_jacobi(self.pos, sum_grad=False).squeeze()
+            grad_auto = self.wf.gradients_autograd(self.pos)
+
+            assert torch.allclose(grads.sum(), grad_auto.sum())
+
+            grads = grads.reshape(self.nbatch, self.wf.nelec, 3)
+            grad_auto = grad_auto.reshape(self.nbatch, self.wf.nelec, 3)
+            assert torch.allclose(grads, grad_auto)
+
+        def test_gradients_pdf(self):
+            grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
+            grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
+
+            assert torch.allclose(grads_pdf.sum(), grads_auto.sum())
+
+    class BackFlowWaveFunctionBaseTest(WaveFunctionBaseTest):
+        def test_jacobian_mo(self):
+            """Jacobian of the BF MOs."""
+
+            mo = self.wf.pos2mo(self.pos)
+            dmo = self.wf.pos2mo(self.pos, derivative=1)
+
+            dmo_grad = grad(mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
+            assert torch.allclose(dmo.sum(), dmo_grad.sum())
+
+            psum_mo = dmo.sum(-1).sum(-1)
+            psum_mo_grad = dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)
+            psum_mo_grad = psum_mo_grad.T
+            assert torch.allclose(psum_mo, psum_mo_grad)
+
+        def test_grad_mo(self):
+            """Gradients of the BF MOs."""
+
+            mo = self.wf.pos2mo(self.pos)
+
+            dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
+            dmo = self.wf.ao2mo(dao)
+
+            dmo_grad = grad(mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
+            assert torch.allclose(dmo.sum(), dmo_grad.sum())
+
+            dmo = dmo.sum(-1).sum(-1)
+            dmo_grad = dmo_grad.T
+
+            assert torch.allclose(dmo, dmo_grad)
+
+        def test_hess_mo(self):
+            """Hessian of the MOs."""
+            val = self.wf.pos2mo(self.pos)
+
+            d2val_grad = hess(val, self.pos)
+            d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
+            d2val = self.wf.ao2mo(d2ao)
+
+            assert torch.allclose(d2val.sum(), d2val_grad.sum())
+
+            d2val = d2val.reshape(4, 3, 5, 4, 6).sum(1).sum(-1).sum(-1)
+            d2val_grad = d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)
+            d2val_grad = d2val_grad.T
+            assert torch.allclose(d2val, d2val_grad)
+
+        def test_gradients_wf(self):
+            pass
+
+        def test_gradients_pdf(self):
+            pass
diff --git a/tests/wavefunction/jastrows/__init__.py b/tests/wavefunction/jastrows/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/distance/__init__.py b/tests/wavefunction/jastrows/distance/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
index 0830380b..a79023e5 100644
--- a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
+++ b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
@@ -10,21 +10,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -32,7 +27,6 @@ def hess(out, pos):
 
 
 class TestElecElecDistance(unittest.TestCase):
-
     def setUp(self):
         self.nup, self.ndown = 1, 1
         self.nelec = self.nup + self.ndown
@@ -73,15 +67,14 @@ def test_grad_distance(self):
         dr = di_r + dj_r
 
         # compute the der with autograd
-        dr_grad = grad(r, self.pos,
-                       grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
 
         # check sum
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
+        assert torch.allclose(dr.sum(), dr_grad.sum(), atol=1e-5)
 
         # see the notes for the explanation of the factor 2
         dr = dr.sum(-1).permute(0, 2, 1).reshape(5, -1)
-        assert(torch.allclose(dr, dr_grad))
+        assert torch.allclose(dr, dr_grad)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/elec_elec/__init__.py b/tests/wavefunction/jastrows/elec_elec/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
new file mode 100644
index 00000000..3e325669
--- /dev/null
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -0,0 +1,96 @@
+import unittest
+from torch.autograd import grad, gradcheck, Variable
+
+import torch
+
+
+def hess(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+
+    for idim in range(jacob.shape[1]):
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, idim] = tmp[:, idim]
+
+    return hess
+
+
+class BaseTestJastrow:
+    class ElecElecJastrowBaseTest(unittest.TestCase):
+        def setUp(self) -> None:
+            """Init the test case"""
+
+            def jastrow_callable(pos, derivative=0, sum_grad=False):
+                """Empty callable for jastrow"""
+                return None
+
+            self.jastrow = jastrow_callable
+            self.nbatch = None
+            self.pos = None
+
+        def test_jastrow(self):
+            """simply checks that the values are not crashing."""
+            _ = self.jastrow(self.pos)
+
+        def test_permutation(self):
+            jval = self.jastrow(self.pos)
+
+            # test spin up
+            pos_xup = self.pos.clone()
+            perm_up = list(range(self.nelec))
+            perm_up[0] = 1
+            perm_up[1] = 0
+            pos_xup = pos_xup.reshape(self.nbatch, self.nelec, 3)
+            pos_xup = pos_xup[:, perm_up, :].reshape(self.nbatch, self.nelec * 3)
+
+            jval_xup = self.jastrow(pos_xup)
+            assert torch.allclose(jval, jval_xup)
+
+        def test_grad_distance(self):
+            r = self.jastrow.edist(self.pos)
+            dr = self.jastrow.edist(self.pos, derivative=1)
+            dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
+            gradcheck(self.jastrow.edist, self.pos)
+
+            assert torch.allclose(dr.sum(), dr_grad.sum(), atol=1e-5)
+
+        def test_sum_grad_jastrow(self):
+            val = self.jastrow(self.pos)
+            dval = self.jastrow(self.pos, derivative=1)
+            dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
+
+            dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
+            gradcheck(self.jastrow, self.pos)
+
+            assert torch.allclose(dval, dval_grad)
+            assert torch.allclose(dval.sum(), dval_grad.sum())
+
+        def test_grad_jastrow(self):
+            val = self.jastrow(self.pos)
+            dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
+            print(dval.shape)
+            dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
+
+            dval_grad = dval_grad.view(self.nbatch, self.nelec, 3)
+
+            assert torch.allclose(dval, dval_grad.transpose(1, 2))
+            assert torch.allclose(dval.sum(), dval_grad.sum())
+
+        def test_hess_jastrow(self):
+            val = self.jastrow(self.pos)
+            d2val_grad = hess(val, self.pos)
+            d2val = self.jastrow(self.pos, derivative=2)
+
+            assert torch.allclose(
+                d2val, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2)
+            )
+
+            assert torch.allclose(d2val.sum(), d2val_grad.sum())
diff --git a/tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py b/tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py
index 8f401004..3ef28871 100644
--- a/tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py
+++ b/tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py
@@ -1,9 +1,5 @@
-import torch
-from torch.autograd import grad
-
-
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
@@ -48,9 +44,10 @@ def setUp(self):
 
         self.nup, self.ndown = 2, 2
         self.nelec = self.nup + self.ndown
+        self.mol = SimpleNamespace(nup=self.nup, ndown=self.ndown)
         self.nmo = 10
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
+            self.mol,
             FullyConnectedJastrowKernel,
             orbital_dependent_kernel=True,
             number_of_orbitals=self.nmo
@@ -62,7 +59,7 @@ def setUp(self):
 
     def test_jastrow(self):
         """simply checks that the values are not crashing."""
-        val = self.jastrow(self.pos)
+        _ = self.jastrow(self.pos)
 
     def test_grad_jastrow(self):
         """Checks the values of the gradients."""
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index 57bbcf00..697af246 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -1,13 +1,11 @@
-import torch
-from torch.autograd import grad
-
-
 import unittest
-
 import numpy as np
 import torch
-from torch.autograd import Variable, grad
 
+
+from .base_elec_elec_jastrow_test import BaseTestJastrow
+
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 from qmctorch.utils import set_torch_double_precision
@@ -15,92 +13,20 @@
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestGenericJastrow(unittest.TestCase):
-
+class TestGenericJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.nup, self.ndown = 4, 4
-        self.nelec = self.nup + self.ndown
-        self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
-            FullyConnectedJastrowKernel)
+        mol = SimpleNamespace(nup=4, ndown=4)
+        self.nelec = mol.nup + mol.ndown
+
+        self.jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
         self.nbatch = 5
 
-        self.pos = 1E-1 * torch.rand(self.nbatch, self.nelec * 3)
+        self.pos = 1e-1 * torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
-    def test_jastrow(self):
-        """simply checks that the values are not crashing."""
-        val = self.jastrow(self.pos)
-
-    def test_grad_jastrow(self):
-        """Checks the values of the gradients."""
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
-
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-
-        dval_grad = dval_grad.reshape(
-            self.nbatch, self.nelec, 3).permute(0, 2, 1)
-
-        assert(torch.allclose(dval, dval_grad))
-
-    def test_jacobian_jastrow(self):
-        """Checks the values of the gradients."""
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1)
-
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-
-        dval_grad = dval_grad.reshape(
-            self.nbatch, self.nelec, 3).permute(0, 2, 1).sum(-2)
-
-        assert torch.allclose(dval, dval_grad)
-
-    def test_hess_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        d2val = self.jastrow(self.pos, derivative=2)
-        d2val_grad = hess(val, self.pos)
-        # print(d2val)
-        # print(d2val_grad.reshape(
-        #     self.nbatch, self.nelec, 3).sum(2))
-        assert torch.allclose(d2val, d2val_grad.reshape(
-            self.nbatch, self.nelec, 3).sum(2))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 710c5ab4..7d69096b 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -1,8 +1,9 @@
 import unittest
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
 
+from .base_elec_elec_jastrow_test import BaseTestJastrow
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
@@ -10,105 +11,22 @@
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestPadeJastrow(unittest.TestCase):
-
+class TestPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.nup, self.ndown = 2, 2
-        self.nelec = self.nup + self.ndown
+        mol = SimpleNamespace(nup=2, ndown=2)
+        self.nelec = mol.nup + mol.ndown
+
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
-            PadeJastrowKernel,
-            kernel_kwargs={'w': 0.1})
+            mol, PadeJastrowKernel, kernel_kwargs={"w": 0.1}
+        )
         self.nbatch = 5
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
-    def test_grad_distance(self):
-
-        r = self.jastrow.edist(self.pos)
-        dr = self.jastrow.edist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
-        gradcheck(self.jastrow.edist, self.pos)
-
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
-
-    def test_sum_grad_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
-        gradcheck(self.jastrow, self.pos)
-
-        assert torch.allclose(dval, dval_grad)
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
-
-    def test_grad_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3)
-
-        assert torch.allclose(dval, dval_grad.transpose(1, 2))
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
-
-    def test_hess_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos)
-        d2val = self.jastrow(self.pos, derivative=2)
-
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
 
 if __name__ == "__main__":
     unittest.main()
-    # t = TestPadeJastrow()
-    # t.setUp()
-    # t.test_grad_jastrow()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
index befa46e1..d9144999 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -1,8 +1,11 @@
-import torch
-from torch.autograd import Variable, grad, gradcheck
 import unittest
 import numpy as np
+import torch
+
 
+from .base_elec_elec_jastrow_test import BaseTestJastrow
+
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
 from qmctorch.utils import set_torch_double_precision
@@ -10,85 +13,28 @@
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestPadeJastrowPolynom(unittest.TestCase):
-
+class TestPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.nup, self.ndown = 4, 4
-        self.nelec = self.nup + self.ndown
+        mol = SimpleNamespace(nup=4, ndown=4)
+        self.nelec = mol.nup + mol.ndown
+
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown, PadeJastrowPolynomialKernel,
-            kernel_kwargs={'order': 5,
-                           'weight_a': 0.1*torch.ones(5),
-                           'weight_b': 0.1*torch.ones(5)})
+            mol,
+            PadeJastrowPolynomialKernel,
+            kernel_kwargs={
+                "order": 5,
+                "weight_a": 0.1 * torch.ones(5),
+                "weight_b": 0.1 * torch.ones(5),
+            },
+        )
         self.nbatch = 10
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
-    def test_grad_distance(self):
-
-        r = self.jastrow.edist(self.pos)
-        dr = self.jastrow.edist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
-        gradcheck(self.jastrow.edist, self.pos)
-
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
-
-    def test_grad_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-        gradcheck(self.jastrow, self.pos)
-
-        assert torch.allclose(dval, dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
-
-    def test_hess_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos)
-        d2val = self.jastrow(self.pos, derivative=2)
-
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
index 2e247337..e5fb91da 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -1,9 +1,10 @@
 import unittest
-
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
 
+from .base_elec_elec_jastrow_test import BaseTestJastrow
+
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
@@ -11,75 +12,22 @@
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestScaledPadeJastrow(unittest.TestCase):
-
+class TestScaledPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.nup, self.ndown = 4, 4
-        self.nelec = self.nup + self.ndown
+        mol = SimpleNamespace(nup=2, ndown=2)
+        self.nelec = mol.nup + mol.ndown
+
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
-            PadeJastrowKernel,
-            kernel_kwargs={'w': 0.1},
-            scale=True)
+            mol, PadeJastrowKernel, kernel_kwargs={"w": 0.1}, scale=True
+        )
         self.nbatch = 5
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
-    def test_grad_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
-        gradcheck(self.jastrow, self.pos)
-
-        assert torch.allclose(dval, dval_grad)
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
-
-    def test_hess_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos)
-        d2val = self.jastrow(self.pos, derivative=2)
-
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow_polynom.py b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow_polynom.py
index 99699aa1..533d0956 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow_polynom.py
@@ -1,9 +1,10 @@
 import unittest
-
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
 
+
+from .base_elec_elec_jastrow_test import BaseTestJastrow
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
 from qmctorch.utils import set_torch_double_precision
@@ -11,90 +12,29 @@
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestScaledPadeJastrowPolynom(unittest.TestCase):
-
+class TestScaledPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.nup, self.ndown = 4, 4
-        self.nelec = self.nup + self.ndown
+        mol = SimpleNamespace(nup=4, ndown=4)
+        self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown, PadeJastrowPolynomialKernel,
-            kernel_kwargs={'order': 5,
-                           'weight_a': 0.1*torch.ones(5),
-                           'weight_b': 0.1*torch.ones(5)},
-            scale=True)
-
-        self.nbatch = 5
+            mol,
+            PadeJastrowPolynomialKernel,
+            kernel_kwargs={
+                "order": 5,
+                "weight_a": 0.1 * torch.ones(5),
+                "weight_b": 0.1 * torch.ones(5),
+            },
+            scale=True,
+        )
+        self.nbatch = 10
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
-    def test_grad_distance(self):
-
-        r = self.jastrow.edist(self.pos)
-        dr = self.jastrow.edist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
-        gradcheck(self.jastrow.edist, self.pos)
-
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
-
-    def test_grad_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
-        gradcheck(self.jastrow, self.pos)
-
-        assert torch.allclose(dval, dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
-
-    def test_hess_jastrow(self):
-
-        val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos)
-        d2val_grad = d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
-
-        d2val = self.jastrow(self.pos, derivative=2)
-
-        assert torch.allclose(d2val, d2val_grad)
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/__init__.py b/tests/wavefunction/jastrows/elec_elec_nuc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 5d116766..800bce94 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
@@ -1,5 +1,4 @@
 import torch
-from torch import nn
 from torch.autograd import grad
 from torch.autograd.variable import Variable
 
@@ -15,19 +14,19 @@ def _hess(val, pos):
     """
     print(pos.shape)
     print(val.shape)
-    gval = grad(val, pos,
-                grad_outputs=torch.ones_like(val),
-                create_graph=True)[0]
+    gval = grad(val, pos, grad_outputs=torch.ones_like(val), create_graph=True)[0]
 
     grad_out = Variable(torch.ones(*gval.shape[:-1]))
     hval = torch.zeros_like(gval)
 
     for idim in range(gval.shape[-1]):
-
-        tmp = grad(gval[..., idim], pos,
-                   grad_outputs=grad_out,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            gval[..., idim],
+            pos,
+            grad_outputs=grad_out,
+            only_inputs=True,
+            create_graph=True,
+        )[0]
         hval[..., idim] = tmp[..., idim]
 
     return hval, gval
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_boys_handy.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_boys_handy.py
index 7791d9b9..adea59c4 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_boys_handy.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_boys_handy.py
@@ -1,5 +1,5 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
@@ -13,21 +13,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -35,53 +30,46 @@ def hess(out, pos):
 
 
 class TestThreeBodyBoysHandy(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         self.nup, self.ndown = 4, 4
         self.nelec = self.nup + self.ndown
         self.natom = 4
-        self.atoms = 0.1*torch.rand(self.natom, 3)
+        self.atoms = 0.1 * np.random.rand(self.natom, 3)
+        self.mol = SimpleNamespace(
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.nup, self.ndown, self.atoms, BoysHandyJastrowKernel)
+            self.mol, BoysHandyJastrowKernel
+        )
         self.nbatch = 5
 
-        self.pos = 0.1*torch.rand(self.nbatch, self.nelec * 3)
+        self.pos = 0.1 * torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
     def test_grad_elel_distance(self):
-
         r = self.jastrow.elel_dist(self.pos)
         dr = self.jastrow.elel_dist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
 
         dr_grad = dr_grad.reshape(self.nbatch, self.nelec, 3)
         dr = dr.sum(-1).permute(0, 2, 1)
 
-        assert(torch.allclose(2*dr, dr_grad, atol=1E-5))
+        assert torch.allclose(2 * dr, dr_grad, atol=1e-5)
 
     def test_grad_elnu_distance(self):
-
         r = self.jastrow.elnu_dist(self.pos)
         dr = self.jastrow.elnu_dist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
 
         dr_grad = dr_grad.reshape(self.nbatch, self.nelec, 3)
         dr = dr.sum(-1).permute(0, 2, 1)
 
-        assert(torch.allclose(dr, dr_grad, atol=1E-5))
+        assert torch.allclose(dr, dr_grad, atol=1e-5)
 
     def test_symmetry(self):
-
         val = self.jastrow(self.pos)
 
         # test spin up
@@ -90,54 +78,41 @@ def test_symmetry(self):
         perm_up[0] = 1
         perm_up[1] = 0
         pos_xup = pos_xup.reshape(self.nbatch, self.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.nelec*3)
+        pos_xup = pos_xup[:, perm_up, :].reshape(self.nbatch, self.nelec * 3)
 
         val_xup = self.jastrow(pos_xup)
 
-        assert(torch.allclose(val, val_xup, atol=1E-3))
+        assert torch.allclose(val, val_xup, atol=1e-3)
 
     def test_jacobian_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
 
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
         assert torch.allclose(dval, dval_grad)
 
     def test_grad_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3)
 
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
         # print(dval.permute(0, 2, 1))
         # print(dval_grad)
         assert torch.allclose(dval.permute(0, 2, 1), dval_grad)
 
     def test_hess_jastrow(self):
-
         val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos).view(
-            self.nbatch, self.nelec, 3).sum(2)
+        d2val_grad = hess(val, self.pos).view(self.nbatch, self.nelec, 3).sum(2)
         d2val = self.jastrow(self.pos, derivative=2)
         # print(torch.abs(d2val_grad-d2val))
 
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
         assert torch.allclose(d2val, d2val_grad)
 
 
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_fully_connected.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_fully_connected.py
index d09926b0..6a7d6890 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_fully_connected.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_three_body_jastrow_fully_connected.py
@@ -1,5 +1,5 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
@@ -13,21 +13,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -35,90 +30,72 @@ def hess(out, pos):
 
 
 class TestThreeBodyFullyConnected(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         self.nup, self.ndown = 4, 4
         self.nelec = self.nup + self.ndown
         self.natom = 4
-        self.atoms = 0.1*torch.rand(self.natom, 3)
+        self.atoms = 0.1 * torch.rand(self.natom, 3)
+        self.mol = SimpleNamespace(
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.nup, self.ndown, self.atoms, FullyConnectedJastrowKernel)
+            self.mol, FullyConnectedJastrowKernel
+        )
         self.nbatch = 5
 
-        self.pos = 0.1*torch.rand(self.nbatch, self.nelec * 3)
+        self.pos = 0.1 * torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
     def test_grad_elel_distance(self):
-
         r = self.jastrow.elel_dist(self.pos)
         dr = self.jastrow.elel_dist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
 
         dr_grad = dr_grad.reshape(self.nbatch, self.nelec, 3)
         dr = dr.sum(-1).permute(0, 2, 1)
 
-        assert(torch.allclose(2*dr, dr_grad, atol=1E-5))
+        assert torch.allclose(2 * dr, dr_grad, atol=1e-5)
 
     def test_grad_elnu_distance(self):
-
         r = self.jastrow.elnu_dist(self.pos)
         dr = self.jastrow.elnu_dist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
 
         dr_grad = dr_grad.reshape(self.nbatch, self.nelec, 3)
         dr = dr.sum(-1).permute(0, 2, 1)
 
-        assert(torch.allclose(dr, dr_grad, atol=1E-5))
+        assert torch.allclose(dr, dr_grad, atol=1e-5)
 
     def test_jacobian_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
 
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
         assert torch.allclose(dval, dval_grad)
 
     def test_grad_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3)
 
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
         assert torch.allclose(dval.permute(0, 2, 1), dval_grad)
 
     def test_hess_jastrow(self):
-
         val = self.jastrow(self.pos)
-        d2val_grad = hess(val, self.pos).view(
-            self.nbatch, self.nelec, 3).sum(2)
+        d2val_grad = hess(val, self.pos).view(self.nbatch, self.nelec, 3).sum(2)
         d2val = self.jastrow(self.pos, derivative=2)
         print(d2val_grad)
         print(d2val)
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
         assert torch.allclose(d2val, d2val_grad)
 
 
diff --git a/tests/wavefunction/jastrows/elec_nuc/__init__.py b/tests/wavefunction/jastrows/elec_nuc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
index 63a44c3f..8fabd3c6 100644
--- a/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
+++ b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
@@ -1,5 +1,5 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
@@ -13,21 +13,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -35,58 +30,49 @@ def hess(out, pos):
 
 
 class TestElectronNucleiGeneric(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         self.nup, self.ndown = 4, 4
         self.nelec = self.nup + self.ndown
         self.atoms = torch.rand(4, 3)
+        self.mol = SimpleNamespace(
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronNuclei(
-            self.nup, self.ndown, self.atoms, FullyConnectedJastrowKernel)
+            self.mol, FullyConnectedJastrowKernel
+        )
         self.nbatch = 5
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
     def test_grad_distance(self):
-
         r = self.jastrow.edist(self.pos)
         dr = self.jastrow.edist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
         gradcheck(self.jastrow.edist, self.pos)
 
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
+        assert torch.allclose(dr.sum(), dr_grad.sum(), atol=1e-5)
 
     def test_grad_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
 
         assert torch.allclose(dval, dval_grad)
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
 
     def test_hess_jastrow(self):
-
         val = self.jastrow(self.pos)
         d2val_grad = hess(val, self.pos)
         d2val = self.jastrow(self.pos, derivative=2)
 
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_pade_jastrow.py b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_pade_jastrow.py
index 0b5e7e6d..6a432f4a 100644
--- a/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_pade_jastrow.py
@@ -1,9 +1,8 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-
 from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
@@ -14,21 +13,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -36,59 +30,48 @@ def hess(out, pos):
 
 
 class TestElectronNucleiPadeJastrow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         self.nup, self.ndown = 4, 4
         self.nelec = self.nup + self.ndown
         self.atoms = torch.rand(4, 3)
-        self.jastrow = JastrowFactorElectronNuclei(
-            self.nup, self.ndown, self.atoms, PadeJastrowKernel)
+        self.mol = SimpleNamespace(
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
+        self.jastrow = JastrowFactorElectronNuclei(self.mol, PadeJastrowKernel)
         self.nbatch = 5
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
     def test_grad_distance(self):
-
         r = self.jastrow.edist(self.pos)
         dr = self.jastrow.edist(self.pos, derivative=1)
-        dr_grad = grad(
-            r,
-            self.pos,
-            grad_outputs=torch.ones_like(r))[0]
+        dr_grad = grad(r, self.pos, grad_outputs=torch.ones_like(r))[0]
         gradcheck(self.jastrow.edist, self.pos)
 
-        assert(torch.allclose(dr.sum(), dr_grad.sum(), atol=1E-5))
+        assert torch.allclose(dr.sum(), dr_grad.sum(), atol=1e-5)
 
     def test_grad_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
         gradcheck(self.jastrow, self.pos)
 
         assert torch.allclose(dval, dval_grad)
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
 
     def test_hess_jastrow(self):
-
         val = self.jastrow(self.pos)
         d2val_grad = hess(val, self.pos)
         d2val = self.jastrow(self.pos, derivative=2)
 
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/graph/__init__.py b/tests/wavefunction/jastrows/graph/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
new file mode 100644
index 00000000..ba007f12
--- /dev/null
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -0,0 +1,111 @@
+import unittest
+import numpy as np
+import torch
+from torch.autograd import Variable, grad
+from types import SimpleNamespace
+from qmctorch.wavefunction.jastrows.graph.mgcn_jastrow import MGCNJastrowFactor
+
+torch.set_default_tensor_type(torch.DoubleTensor)
+
+
+def hess(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+
+    for idim in range(jacob.shape[1]):
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, idim] = tmp[:, idim]
+
+    return hess
+
+
+class TestGraphJastrow(unittest.TestCase):
+    def setUp(self):
+        torch.manual_seed(0)
+        np.random.seed(0)
+
+        self.nup, self.ndown = 2, 2
+        self.nelec = self.nup + self.ndown
+        self.atomic_pos = np.random.rand(2, 3)
+        self.atom_types = ["Li", "H"]
+
+        self.mol = SimpleNamespace(
+            nup=self.nup,
+            ndown=self.ndown,
+            atom_coords=self.atomic_pos,
+            atoms=self.atom_types,
+        )
+
+        self.jastrow = MGCNJastrowFactor(
+            self.mol,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
+
+        self.nbatch = 5
+
+        self.pos = -1.0 + 2 * torch.rand(self.nbatch, self.nelec * 3)
+        self.pos.requires_grad = True
+
+    def test_permutation(self):
+        jval = self.jastrow(self.pos)
+
+        # test spin up
+        pos_xup = self.pos.clone()
+        perm_up = list(range(self.nelec))
+        perm_up[0] = 1
+        perm_up[1] = 0
+        pos_xup = pos_xup.reshape(self.nbatch, self.nelec, 3)
+        pos_xup = pos_xup[:, perm_up, :].reshape(self.nbatch, self.nelec * 3)
+
+        jval_xup = self.jastrow(pos_xup)
+        assert torch.allclose(jval, jval_xup)
+
+    def test_sum_grad_jastrow(self):
+        val = self.jastrow(self.pos)
+        dval = self.jastrow(self.pos, derivative=1)
+
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
+
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
+
+        assert torch.allclose(dval, dval_grad)
+        assert torch.allclose(dval.sum(), dval_grad.sum())
+
+    def test_grad_jastrow(self):
+        val = self.jastrow(self.pos)
+        dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
+
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
+
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3)
+
+        assert torch.allclose(dval, dval_grad.transpose(1, 2))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
+
+    def test_hess_jastrow(self):
+        val = self.jastrow(self.pos)
+        d2val_grad = hess(val, self.pos)
+        d2val = self.jastrow(self.pos, derivative=2)
+
+        assert torch.allclose(d2val, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
+
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
+
+
+if __name__ == "__main__":
+    unittest.main()
+    # t = TestGraphJastrow()
+    # t.setUp()
+    # t.test_permutation()
+    # t.test_grad_jastrow()
+    # t.test_sum_grad_jastrow()
+    # t.test_hess_jastrow()
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index dcb9c806..5ea717db 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -1,13 +1,21 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
 
-from qmctorch.wavefunction.jastrows.jastrow_factor_combined_terms import JastrowFactorCombinedTerms
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel as PadeJastrowKernelElecElec
-from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import PadeJastrowKernel as PadeJastrowKernelElecNuc
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import BoysHandyJastrowKernel, FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.jastrow_factor_combined_terms import (
+    JastrowFactorCombinedTerms,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecElec,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecNuc,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import (
+    BoysHandyJastrowKernel,
+)
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
@@ -16,21 +24,16 @@
 def hess(out, pos):
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -38,27 +41,27 @@ def hess(out, pos):
 
 
 class TestJastrowCombinedTerms(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         self.nup, self.ndown = 4, 4
         self.nelec = self.nup + self.ndown
-        self.atoms = torch.rand(4, 3)
+        self.atoms = np.random.rand(4, 3)
+
+        self.mol = SimpleNamespace(
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
+
         self.jastrow = JastrowFactorCombinedTerms(
-            self.nup, self.ndown, self.atoms,
+            self.mol,
             jastrow_kernel={
-                'ee': PadeJastrowKernelElecElec,
-                'en': PadeJastrowKernelElecNuc,
-                'een': BoysHandyJastrowKernel
+                "ee": PadeJastrowKernelElecElec,
+                "en": PadeJastrowKernelElecNuc,
+                "een": BoysHandyJastrowKernel,
             },
-            jastrow_kernel_kwargs={
-                'ee': {'w': 1.},
-                'en': {'w': 1.},
-                'een': {}
-            })
+            jastrow_kernel_kwargs={"ee": {"w": 1.0}, "en": {"w": 1.0}, "een": {}},
+        )
 
         self.nbatch = 5
 
@@ -66,33 +69,26 @@ def setUp(self):
         self.pos.requires_grad = True
 
     def test_jastrow(self):
-        val = self.jastrow(self.pos)
+        _ = self.jastrow(self.pos)
 
     def test_grad_jastrow(self):
-
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        dval_grad = grad(
-            val,
-            self.pos,
-            grad_outputs=torch.ones_like(val))[0]
+        dval_grad = grad(val, self.pos, grad_outputs=torch.ones_like(val))[0]
 
-        dval_grad = dval_grad.view(
-            self.nbatch, self.nelec, 3).sum(2)
+        dval_grad = dval_grad.view(self.nbatch, self.nelec, 3).sum(2)
         gradcheck(self.jastrow, self.pos)
 
         assert torch.allclose(dval, dval_grad)
-        assert(torch.allclose(dval.sum(), dval_grad.sum()))
+        assert torch.allclose(dval.sum(), dval_grad.sum())
 
     def test_hess_jastrow(self):
-
         val = self.jastrow(self.pos)
         d2val_grad = hess(val, self.pos)
         d2val = self.jastrow(self.pos, derivative=2)
 
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-        assert torch.allclose(d2val, d2val_grad.view(
-            self.nbatch, self.nelec, 3).sum(2))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
+        assert torch.allclose(d2val, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/backflow/__init__.py b/tests/wavefunction/orbitals/backflow/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_base.py b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
new file mode 100644
index 00000000..1ca1d221
--- /dev/null
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
@@ -0,0 +1,297 @@
+import unittest
+
+import torch
+from torch.autograd import Variable, grad
+import numpy as np
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
+
+torch.manual_seed(101)
+np.random.seed(101)
+
+
+def hess(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+
+    for idim in range(jacob.shape[1]):
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, idim] = tmp[:, idim]
+
+    return hess
+
+
+def hess_single_element(out, inp):
+    shape = out.shape
+    out = out.reshape(-1, 1)
+
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape))
+
+    hess = grad(jacob, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    return hess.reshape(*shape)
+
+class BaseTestCases:
+    class TestBackFlowKernelBase(unittest.TestCase):
+
+        def setUp(self):
+            pass 
+        
+        def test_derivative_backflow_kernel(self):
+            """Test the derivative of the kernel function
+            wrt the elec-elec distance."""
+
+            ree = self.edist(self.pos)
+            bf_kernel = self.kernel(ree)
+            dbf_kernel_auto = grad(bf_kernel, ree, grad_outputs=torch.ones_like(bf_kernel))[
+                0
+            ]
+            dbf_kernel = self.kernel(ree, derivative=1)
+
+            assert torch.allclose(dbf_kernel.sum(), dbf_kernel_auto.sum())
+            assert torch.allclose(dbf_kernel, dbf_kernel_auto)
+
+        def test_second_derivative_backflow_kernel(self):
+            """Test the 2nd derivative of the kernel function
+            wrt the elec-elec distance."""
+
+            ree = self.edist(self.pos)
+            bf_kernel = self.kernel(ree)
+
+            d2bf_kernel_auto = hess_single_element(bf_kernel, ree)
+
+            d2bf_kernel = self.kernel(ree, derivative=2)
+
+            assert torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum())
+            assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
+
+        def test_derivative_backflow_kernel_pos(self):
+            """Test the derivative of the kenel function wrt the pos of the elecs.
+            Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
+            and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
+            i.e. edist(pos,1) returns half of the derivatives
+
+            so to obatin the same values than autograd we need to double d/dx_i r_ij
+            """
+
+            # compute the ee dist
+            ree = self.edist(self.pos)
+
+            # compute the kernel values
+            bfpos = self.kernel(ree)
+
+            # computes the derivative of the ee dist
+            di_ree = self.edist(self.pos, 1)
+            dj_ree = di_ree
+
+            # compute the derivative of the kernal values
+            bf_der = self.kernel(ree, derivative=1)
+
+            # get the der of the bf wrt the first elec in ree
+            di_bfpos = bf_der.unsqueeze(1) * di_ree
+
+            # need to take the transpose here
+            # get the der of the bf wrt the second elec in ree
+            dj_bfpos = (bf_der.permute(0, 2, 1)).unsqueeze(1) * dj_ree
+
+            # add both components
+            d_bfpos = di_bfpos + dj_bfpos
+
+            # computes the the derivative of the kernal values with autograd
+            dbfpos_grad = grad(bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
+
+            # checksum
+            assert torch.allclose(d_bfpos.sum(), dbfpos_grad.sum())
+
+            # reshape and check individual elements
+            dbfpos = d_bfpos.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
+            assert torch.allclose(dbfpos, dbfpos_grad)
+
+        def test_second_derivative_backflow_kernel_pos(self):
+            """Test the derivative of the kenel function wrt the pos of the elecs.
+            Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
+            and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
+            i.e. edist(pos,1) returns half of the derivatives
+            Same thing for edist(pos,2)
+
+            so to obatin the same values than autograd we need to double d/dx_i r_ij
+            """
+
+            # compute the ee dist
+            ree = self.edist(self.pos)
+
+            # compute the kernel values
+            bf_kernel = self.kernel(ree)
+
+            # computes the derivative of the ee dist
+            di_ree = self.edist(self.pos, 1)
+            dj_ree = di_ree
+
+            # computes the derivative of the ee dist
+            d2i_ree = self.edist(self.pos, 2)
+            d2j_ree = d2i_ree
+
+            # compute the derivative of the kernel values
+            d2bf_kernel = self.kernel(ree, derivative=2).unsqueeze(1) * di_ree * di_ree
+
+            d2bf_kernel += (
+                self.kernel(ree, derivative=2).permute(0, 2, 1).unsqueeze(1)
+                * dj_ree
+                * dj_ree
+            )
+
+            d2bf_kernel += self.kernel(ree, derivative=1).unsqueeze(1) * d2i_ree
+
+            d2bf_kernel += (
+                self.kernel(ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_ree
+            )
+
+            # computes the the derivative of the kernal values with autograd
+            d2bf_kernel_auto = hess(bf_kernel, self.pos)
+
+            # checksum
+            assert torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum())
+
+            # reshape and check individual elements
+            d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
+
+            assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
+
+    class TestBackFlowTransformationBase(unittest.TestCase):
+        def setUp(self):
+            pass
+
+        def test_backflow_derivative(self):
+            """Test the derivative of the bf coordinate wrt the initial positions."""
+
+            # compute backflow pos
+            q = self.backflow_trans(self.pos)
+
+            # compute der of the backflow pos wrt the
+            # original pos
+            dq = self.backflow_trans(self.pos, derivative=1).squeeze()
+
+            # compute der of the backflow pos wrt the
+            # original pos using autograd
+            dq_grad = grad(q, self.pos, grad_outputs=torch.ones_like(self.pos))[0]
+
+            # checksum
+            assert torch.allclose(dq.sum(), dq_grad.sum())
+
+            # permute and check elements
+            dq = dq.sum([1, 3])
+            dq = dq.permute(0, 2, 1)
+
+            dq_grad = dq_grad.reshape(self.npts, self.mol.nelec, 3)
+            assert torch.allclose(dq, dq_grad)
+
+        def test_backflow_second_derivative(self):
+            """Test the derivative of the bf coordinate wrt the initial positions."""
+
+            # compute backflow pos
+            q = self.backflow_trans(self.pos)
+
+            # compute der of the backflow pos wrt the
+            # original pos
+            d2q = self.backflow_trans(self.pos, derivative=2).squeeze()
+
+            # compute der of the backflow pos wrt the
+            # original pos using autograd
+            d2q_auto = hess(q, self.pos)
+
+            # checksum
+            assert torch.allclose(d2q.sum(), d2q_auto.sum())
+
+            # permute and check elements
+            d2q = d2q.sum([1, 3])
+            d2q = d2q.permute(0, 2, 1)
+            d2q_auto = d2q_auto.reshape(self.npts, self.mol.nelec, 3)
+
+            assert torch.allclose(d2q, d2q_auto)
+
+    class TestOrbitalDependentBackFlowTransformationBase(unittest.TestCase):
+        def setUp(self):
+            pass
+
+        def test_backflow_derivative(self):
+            """Test the derivative of the bf coordinate wrt the initial positions."""
+
+            # compute backflow pos
+            q = self.backflow_trans(self.pos)
+            nao = q.shape[1]
+
+            # compute der of the backflow pos wrt the
+            # original pos
+            dq = self.backflow_trans(self.pos, derivative=1)
+
+            # compute der of the backflow pos wrt the
+            # original pos using autograd
+            dq_grad = None
+            for iq in range(nao):
+                qao = q[:, iq, ...]
+                dqao = grad(
+                    qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True
+                )[0]
+                if dq_grad is None:
+                    dq_grad = dqao
+                else:
+                    dq_grad = torch.cat(
+                        (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis
+                    )
+            # checksum
+            assert torch.allclose(dq.sum(), dq_grad.sum())
+
+            # permute and check elements
+            dq = dq.sum([1, 3])
+            dq = dq.permute(0, 3, 2, 1)
+            dq_grad = dq_grad.reshape(self.npts, nao, self.mol.nelec, 3)
+
+            assert torch.allclose(dq, dq_grad)
+
+        def test_backflow_second_derivative(self):
+            """Test the derivative of the bf coordinate wrt the initial positions."""
+
+            # compute backflow pos
+            q = self.backflow_trans(self.pos)
+            nao = q.shape[1]
+
+            # compute der of the backflow pos wrt the
+            # original pos
+            d2q = self.backflow_trans(self.pos, derivative=2)
+
+            # compute der of the backflow pos wrt the
+            # original pos using autograd
+            d2q_auto = None
+            for iq in range(nao):
+                qao = q[:, iq, ...]
+                d2qao = hess(qao, self.pos)
+                if d2q_auto is None:
+                    d2q_auto = d2qao
+                else:
+                    d2q_auto = torch.cat(
+                        (d2q_auto, d2qao),
+                        axis=self.backflow_trans.backflow_kernel.stack_axis,
+                    )
+
+            # checksum
+            assert torch.allclose(d2q.sum(), d2q_auto.sum())
+
+            # permute and check elements
+            d2q = d2q.sum([1, 3])
+            d2q = d2q.permute(0, 3, 2, 1)
+            d2q_auto = d2q_auto.reshape(self.npts, nao, self.mol.nelec, 3)
+
+            assert torch.allclose(d2q, d2q_auto)
\ No newline at end of file
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
new file mode 100644
index 00000000..cd5736f0
--- /dev/null
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
@@ -0,0 +1,36 @@
+import unittest
+
+import torch
+from torch.autograd import Variable, grad
+import numpy as np
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelExp
+from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
+from qmctorch.utils import set_torch_double_precision
+from .test_backflow_base import BaseTestCases
+set_torch_double_precision()
+
+torch.manual_seed(101)
+np.random.seed(101)
+
+
+class TestBackFlowKernel(BaseTestCases.TestBackFlowKernelBase):
+    def setUp(self):
+        # define the molecule
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
+
+        # define the kernel
+        self.kernel = BackFlowKernelExp(self.mol)
+        self.edist = ElectronElectronDistance(self.mol.nelec)
+
+        # define the grid points
+        self.npts = 11
+        self.pos = torch.rand(self.npts, self.mol.nelec * 3)
+        self.pos = Variable(self.pos)
+        self.pos.requires_grad = True
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
index b90548c0..b4fc52d6 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -1,7 +1,6 @@
 import unittest
 
 import torch
-from pyscf import gto
 from torch import nn
 from torch.autograd import Variable, grad
 import numpy as np
@@ -9,6 +8,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
 from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
+from .test_backflow_base import BaseTestCases
 from qmctorch.utils import set_torch_double_precision
 set_torch_double_precision()
 
@@ -16,62 +16,14 @@
 np.random.seed(101)
 
 
-def hess(out, pos):
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_single_element(out, inp):
-
-    shape = out.shape
-    out = out.reshape(-1, 1)
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape))
-
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
-
-    return hess.reshape(*shape)
-
-
 class GenericBackFlowKernel(BackFlowKernelBase):
-
     def __init__(self, mol, cuda=False):
         """Define a generic kernel to test the auto diff features."""
         super().__init__(mol, cuda)
-        eps = 1E-4
-        self.weight = nn.Parameter(
-            eps * torch.rand(self.nelec, self.nelec)).to(self.device)
+        eps = 1e-4
+        self.weight = nn.Parameter(eps * torch.rand(self.nelec, self.nelec)).to(
+            self.device
+        )
 
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
@@ -88,17 +40,12 @@ def _backflow_kernel(self, ree):
         return self.weight * ree * ree
 
 
-class TestGenericBackFlowKernel(unittest.TestCase):
-
+class TestGenericBackFlowKernel(BaseTestCases.TestBackFlowKernelBase):
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the kernel
         self.kernel = GenericBackFlowKernel(self.mol)
@@ -110,127 +57,6 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_derivative_backflow_kernel(self):
-        """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
-
-        ree = self.edist(self.pos)
-        bf_kernel = self.kernel(ree)
-        dbf_kernel_auto = grad(
-            bf_kernel, ree, grad_outputs=torch.ones_like(bf_kernel))[0]
-        dbf_kernel = self.kernel(ree, derivative=1)
-
-        assert(torch.allclose(dbf_kernel.sum(), dbf_kernel_auto.sum()))
-        assert(torch.allclose(dbf_kernel, dbf_kernel_auto))
-
-    def test_second_derivative_backflow_kernel(self):
-        """Test the 2nd derivative of the kernel function
-           wrt the elec-elec distance."""
-
-        ree = self.edist(self.pos)
-        bf_kernel = self.kernel(ree)
-
-        d2bf_kernel_auto = hess_single_element(bf_kernel, ree)
-
-        d2bf_kernel = self.kernel(ree, derivative=2)
-
-        assert(torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum()))
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
-
-    def test_derivative_backflow_kernel_pos(self):
-        """Test the derivative of the kenel function wrt the pos of the elecs.
-        Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
-        and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
-        i.e. edist(pos,1) returns half of the derivatives
-
-        so to obatin the same values than autograd we need to double d/dx_i r_ij
-        """
-
-        # compute the ee dist
-        ree = self.edist(self.pos)
-
-        # compute the kernel values
-        bfpos = self.kernel(ree)
-
-        # computes the derivative of the ee dist
-        di_ree = self.edist(self.pos, 1)
-        dj_ree = di_ree
-
-        # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
-
-        # get the der of the bf wrt the first elec in ree
-        di_bfpos = bf_der.unsqueeze(1) * di_ree
-
-        # need to take the transpose here
-        # get the der of the bf wrt the second elec in ree
-        dj_bfpos = (bf_der.permute(0, 2, 1)).unsqueeze(1) * dj_ree
-
-        # add both components
-        d_bfpos = di_bfpos + dj_bfpos
-
-        # computes the the derivative of the kernal values with autograd
-        dbfpos_grad = grad(
-            bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
-
-        # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
-
-        # reshape and check individual elements
-        dbfpos = d_bfpos.sum(-1).permute(0, 2,
-                                         1).reshape(self.npts, -1)
-        assert(torch.allclose(dbfpos, dbfpos_grad))
-
-    def test_second_derivative_backflow_kernel_pos(self):
-        """Test the derivative of the kenel function wrt the pos of the elecs.
-        Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
-        and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
-        i.e. edist(pos,1) returns half of the derivatives
-        Same thing for edist(pos,2)
-
-        so to obatin the same values than autograd we need to double d/dx_i r_ij
-        """
-
-        # compute the ee dist
-        ree = self.edist(self.pos)
-
-        # compute the kernel values
-        bf_kernel = self.kernel(ree)
-
-        # computes the derivative of the ee dist
-        di_ree = self.edist(self.pos, 1)
-        dj_ree = di_ree
-
-        # computes the derivative of the ee dist
-        d2i_ree = self.edist(self.pos, 2)
-        d2j_ree = d2i_ree
-
-        # compute the derivative of the kernel values
-        d2bf_kernel = self.kernel(
-            ree, derivative=2).unsqueeze(1) * di_ree * di_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=2).permute(0, 2, 1).unsqueeze(1) * dj_ree * dj_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).unsqueeze(1) * d2i_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_ree
-
-        # computes the the derivative of the kernal values with autograd
-        d2bf_kernel_auto = hess(bf_kernel, self.pos)
-
-        # checksum
-        assert(torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum()))
-
-        # reshape and check individual elements
-        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2,
-                                                  1).reshape(self.npts, -1)
-
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
index 3e377d56..1a19d8eb 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -1,79 +1,25 @@
 import unittest
 
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 import numpy as np
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
 from qmctorch.utils import set_torch_double_precision
+from .test_backflow_base import BaseTestCases
 set_torch_double_precision()
 
 torch.manual_seed(101)
 np.random.seed(101)
 
-
-def hess(out, pos):
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_single_element(out, inp):
-
-    shape = out.shape
-    out = out.reshape(-1, 1)
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape))
-
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
-
-    return hess.reshape(*shape)
-
-
-class TestBackFlowKernel(unittest.TestCase):
-
+class TestBackFlowKernel(BaseTestCases.TestBackFlowKernelBase):
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the kernel
         self.kernel = BackFlowKernelInverse(self.mol)
@@ -85,127 +31,5 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_derivative_backflow_kernel(self):
-        """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
-
-        ree = self.edist(self.pos)
-        bf_kernel = self.kernel(ree)
-        dbf_kernel_auto = grad(
-            bf_kernel, ree, grad_outputs=torch.ones_like(bf_kernel))[0]
-        dbf_kernel = self.kernel(ree, derivative=1)
-
-        assert(torch.allclose(dbf_kernel.sum(), dbf_kernel_auto.sum()))
-        assert(torch.allclose(dbf_kernel, dbf_kernel_auto))
-
-    def test_second_derivative_backflow_kernel(self):
-        """Test the 2nd derivative of the kernel function
-           wrt the elec-elec distance."""
-
-        ree = self.edist(self.pos)
-        bf_kernel = self.kernel(ree)
-
-        d2bf_kernel_auto = hess_single_element(bf_kernel, ree)
-
-        d2bf_kernel = self.kernel(ree, derivative=2)
-
-        assert(torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum()))
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
-
-    def test_derivative_backflow_kernel_pos(self):
-        """Test the derivative of the kenel function wrt the pos of the elecs.
-        Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
-        and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
-        i.e. edist(pos,1) returns half of the derivatives
-
-        so to obatin the same values than autograd we need to double d/dx_i r_ij
-        """
-
-        # compute the ee dist
-        ree = self.edist(self.pos)
-
-        # compute the kernel values
-        bfpos = self.kernel(ree)
-
-        # computes the derivative of the ee dist
-        di_ree = self.edist(self.pos, 1)
-        dj_ree = di_ree
-
-        # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
-
-        # get the der of the bf wrt the first elec in ree
-        di_bfpos = bf_der.unsqueeze(1) * di_ree
-
-        # need to take the transpose here
-        # get the der of the bf wrt the second elec in ree
-        dj_bfpos = (bf_der.permute(0, 2, 1)).unsqueeze(1) * dj_ree
-
-        # add both components
-        d_bfpos = di_bfpos + dj_bfpos
-
-        # computes the the derivative of the kernal values with autograd
-        dbfpos_grad = grad(
-            bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
-
-        # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
-
-        # reshape and check individual elements
-        dbfpos = d_bfpos.sum(-1).permute(0, 2,
-                                         1).reshape(self.npts, -1)
-        assert(torch.allclose(dbfpos, dbfpos_grad))
-
-    def test_second_derivative_backflow_kernel_pos(self):
-        """Test the derivative of the kenel function wrt the pos of the elecs.
-        Note that the derivative edist(pos,1) returns d r_ij = d/dx_i r_ij
-        and that d/dx_j r_ij = d/d_xi r_ij = - d/dx_i r_ji
-        i.e. edist(pos,1) returns half of the derivatives
-        Same thing for edist(pos,2)
-
-        so to obatin the same values than autograd we need to double d/dx_i r_ij
-        """
-
-        # compute the ee dist
-        ree = self.edist(self.pos)
-
-        # compute the kernel values
-        bf_kernel = self.kernel(ree)
-
-        # computes the derivative of the ee dist
-        di_ree = self.edist(self.pos, 1)
-        dj_ree = di_ree
-
-        # computes the derivative of the ee dist
-        d2i_ree = self.edist(self.pos, 2)
-        d2j_ree = d2i_ree
-
-        # compute the derivative of the kernel values
-        d2bf_kernel = self.kernel(
-            ree, derivative=2).unsqueeze(1) * di_ree * di_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=2).permute(0, 2, 1).unsqueeze(1) * dj_ree * dj_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).unsqueeze(1) * d2i_ree
-
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_ree
-
-        # computes the the derivative of the kernal values with autograd
-        d2bf_kernel_auto = hess(bf_kernel, self.pos)
-
-        # checksum
-        assert(torch.allclose(d2bf_kernel.sum(), d2bf_kernel_auto.sum()))
-
-        # reshape and check individual elements
-        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2,
-                                                  1).reshape(self.npts, -1)
-
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index f577f630..8457643c 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -1,82 +1,33 @@
 import unittest
 
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
+from .test_backflow_base import BaseTestCases
 set_torch_double_precision()
 
 torch.manual_seed(101)
 np.random.seed(101)
 
 
-def hess(out, pos):
 
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_single_element(out, inp):
-
-    shape = out.shape
-    out = out.reshape(-1, 1)
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape))
-
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
-
-    return hess.reshape(*shape)
-
-
-class TestBackFlowTransformation(unittest.TestCase):
 
+class TestBackFlowTransformation(BaseTestCases.TestBackFlowTransformationBase):
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the backflow transformation
-        self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse)
+        self.backflow_trans = BackFlowTransformation(self.mol, BackFlowKernelInverse)
 
         # define the grid points
         self.npts = 11
@@ -84,55 +35,6 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_backflow_derivative(self):
-        """Test the derivative of the bf coordinate wrt the initial positions."""
-
-        # compute backflow pos
-        q = self.backflow_trans(self.pos)
-
-        # compute der of the backflow pos wrt the
-        # original pos
-        dq = self.backflow_trans(self.pos, derivative=1)
-
-        # compute der of the backflow pos wrt the
-        # original pos using autograd
-        dq_grad = grad(
-            q, self.pos, grad_outputs=torch.ones_like(self.pos))[0]
-
-        # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
-
-        # permute and check elements
-        dq = dq.sum([1, 3])
-        dq = dq.permute(0, 2, 1)
-
-        dq_grad = dq_grad.reshape(self.npts, self.mol.nelec, 3)
-        assert(torch.allclose(dq, dq_grad))
-
-    def test_backflow_second_derivative(self):
-        """Test the derivative of the bf coordinate wrt the initial positions."""
-
-        # compute backflow pos
-        q = self.backflow_trans(self.pos)
-
-        # compute der of the backflow pos wrt the
-        # original pos
-        d2q = self.backflow_trans(self.pos, derivative=2)
-
-        # compute der of the backflow pos wrt the
-        # original pos using autograd
-        d2q_auto = hess(q, self.pos)
-
-        # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
-
-        # permute and check elements
-        d2q = d2q.sum([1, 3])
-        d2q = d2q.permute(0, 2, 1)
-        d2q_auto = d2q_auto.reshape(self.npts, self.mol.nelec, 3)
-
-        assert(torch.allclose(d2q, d2q_auto))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
new file mode 100644
index 00000000..91983227
--- /dev/null
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -0,0 +1,37 @@
+import unittest
+
+import torch
+from torch.autograd import Variable, grad
+import numpy as np
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
+from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelRBF
+from qmctorch.utils import set_torch_double_precision
+from .test_backflow_base import BaseTestCases
+set_torch_double_precision()
+
+torch.manual_seed(101)
+np.random.seed(101)
+
+
+
+class TestBackFlowTransformation(BaseTestCases.TestBackFlowTransformationBase):
+    def setUp(self):
+        # define the molecule
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
+
+        # define the backflow transformation
+        self.backflow_trans = BackFlowTransformation(self.mol, BackFlowKernelRBF)
+
+        # define the grid points
+        self.npts = 11
+        self.pos = torch.rand(self.npts, self.mol.nelec * 3)
+        self.pos = Variable(self.pos)
+        self.pos.requires_grad = True
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/wavefunction/orbitals/backflow/test_orbital_dependent_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_orbital_dependent_backflow_transformation_pyscf.py
index 9de70ec8..64811123 100644
--- a/tests/wavefunction/orbitals/backflow/test_orbital_dependent_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_orbital_dependent_backflow_transformation_pyscf.py
@@ -1,82 +1,32 @@
 import unittest
 
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.orbitals.backflow.orbital_dependent_backflow_transformation import OrbitalDependentBackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
+from .test_backflow_base import BaseTestCases
 set_torch_double_precision()
 
 torch.manual_seed(101)
 np.random.seed(101)
 
 
-def hess(out, pos):
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_single_element(out, inp):
-
-    shape = out.shape
-    out = out.reshape(-1, 1)
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape))
-
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
-
-    return hess.reshape(*shape)
-
-
-class TestOrbitalDependentBackFlowTransformation(unittest.TestCase):
-
+class TestOrbitalDependentBackFlowTransformation(BaseTestCases.TestOrbitalDependentBackFlowTransformationBase):
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the backflow transformation
-        self.backflow_trans = OrbitalDependentBackFlowTransformation(
-            self.mol, BackFlowKernelInverse)
+        self.backflow_trans = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # set the weights to random
         for ker in self.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -88,72 +38,6 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_backflow_derivative(self):
-        """Test the derivative of the bf coordinate wrt the initial positions."""
-
-        # compute backflow pos
-        q = self.backflow_trans(self.pos)
-        nao = q.shape[1]
-        # compute der of the backflow pos wrt the
-        # original pos
-        dq = self.backflow_trans(self.pos, derivative=1)
-
-        # compute der of the backflow pos wrt the
-        # original pos using autograd
-        dq_grad = None
-        for iq in range(nao):
-            qao = q[:, iq, ...]
-            dqao = grad(
-                qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True)[0]
-            if dq_grad is None:
-                dq_grad = dqao
-            else:
-                dq_grad = torch.cat(
-                    (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis)
-        # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
-
-        # permute and check elements
-        dq = dq.sum([2, 4])
-        dq = dq.permute(0, 1, 3, 2)
-        dq_grad = dq_grad.reshape(self.npts, nao, self.mol.nelec, 3)
-
-        assert(torch.allclose(dq, dq_grad))
-
-    def test_backflow_second_derivative(self):
-        """Test the derivative of the bf coordinate wrt the initial positions."""
-
-        # compute backflow pos
-        q = self.backflow_trans(self.pos)
-        nao = q.shape[1]
-
-        # compute der of the backflow pos wrt the
-        # original pos
-        d2q = self.backflow_trans(self.pos, derivative=2)
-
-        # compute der of the backflow pos wrt the
-        # original pos using autograd
-        d2q_auto = None
-        for iq in range(nao):
-            qao = q[:, iq, ...]
-            d2qao = hess(qao, self.pos)
-            if d2q_auto is None:
-                d2q_auto = d2qao
-            else:
-                d2q_auto = torch.cat(
-                    (d2q_auto, d2qao), axis=self.backflow_trans.backflow_kernel.stack_axis)
-
-        # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
-
-        # permute and check elements
-        d2q = d2q.sum([2, 4])
-        d2q = d2q.permute(0, 1, 3, 2)
-        d2q_auto = d2q_auto.reshape(
-            self.npts, nao,  self.mol.nelec, 3)
-
-        assert(torch.allclose(d2q, d2q_auto))
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
new file mode 100644
index 00000000..c87e16fd
--- /dev/null
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -0,0 +1,103 @@
+import unittest
+import torch
+from torch.autograd import Variable, grad, gradcheck
+
+
+def hess(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+
+    for idim in range(jacob.shape[1]):
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, idim] = tmp[:, idim]
+
+    return hess
+
+
+def hess_mixed_terms(out, pos):
+    # compute the jacobian
+    z = Variable(torch.ones(out.shape))
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
+
+    # compute the diagonal element of the Hessian
+    z = Variable(torch.ones(jacob.shape[0]))
+    hess = torch.zeros(jacob.shape)
+    nelec = pos.shape[1] // 3
+    k = 0
+
+    for ielec in range(nelec):
+        ix = ielec * 3
+        tmp = grad(
+            jacob[:, ix], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, k] = tmp[:, ix + 1]
+        k = k + 1
+        hess[:, k] = tmp[:, ix + 2]
+        k = k + 1
+
+        iy = ielec * 3 + 1
+        tmp = grad(
+            jacob[:, iy], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
+
+        hess[:, k] = tmp[:, iy + 1]
+        k = k + 1
+
+    return hess
+
+
+class BaseTestAO:
+    class BaseTestAOderivatives(unittest.TestCase):
+        def setUp(self):
+            def ao_callable(pos, derivative=0, sum_grad=False, sum_hess=False):
+                """Callable for the AO"""
+                return None
+
+            self.ao = ao_callable
+            self.pos = None
+
+        def test_ao_deriv(self):
+            ao = self.ao(self.pos)
+            dao = self.ao(self.pos, derivative=1)
+            dao_grad = grad(ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
+
+            gradcheck(self.ao, self.pos)
+            assert torch.allclose(dao.sum(), dao_grad.sum())
+
+        def test_ao_grad_sum(self):
+            _ = self.ao(self.pos)
+            dao_sum = self.ao(self.pos, derivative=1, sum_grad=True)
+            dao = self.ao(self.pos, derivative=1, sum_grad=False)
+
+            assert torch.allclose(dao_sum, dao.sum(-1))
+
+        def test_ao_hess(self):
+            ao = self.ao(self.pos)
+            d2ao = self.ao(self.pos, derivative=2)
+            d2ao_grad = hess(ao, self.pos)
+            assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
+
+        def test_ao_hess_sum(self):
+            _ = self.ao(self.pos)
+            d2ao_sum = self.ao(self.pos, derivative=2, sum_hess=True)
+            d2ao = self.ao(self.pos, derivative=2, sum_hess=False)
+            assert torch.allclose(d2ao_sum, d2ao.sum(-1))
+
+        def test_ao_all(self):
+            ao = self.ao(self.pos)
+            dao = self.ao(self.pos, derivative=1, sum_grad=False)
+            d2ao = self.ao(self.pos, derivative=2)
+            ao_all, dao_all, d2ao_all = self.ao(self.pos, derivative=[0, 1, 2])
+
+            assert torch.allclose(ao, ao_all)
+            assert torch.allclose(dao, dao_all)
+            assert torch.allclose(d2ao, d2ao_all)
diff --git a/tests/wavefunction/orbitals/second_derivative.py b/tests/wavefunction/orbitals/second_derivative.py
index 154c5209..f9fa2d4d 100644
--- a/tests/wavefunction/orbitals/second_derivative.py
+++ b/tests/wavefunction/orbitals/second_derivative.py
@@ -1,3 +1,2 @@
-
 def second_derivative(xm1, x0, xp1, eps):
     return (xm1 - 2 * x0 + xp1) / eps / eps
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
index f0a7f2e8..98bf9e20 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -1,91 +1,22 @@
-
 import unittest
 import torch
-
-from torch.autograd import Variable, grad, gradcheck
-
+from torch.autograd import Variable
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 from qmctorch.utils import set_torch_double_precision
+from .base_test_ao import BaseTestAO
 from ...path_utils import PATH_TEST
 
 set_torch_double_precision()
 
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_mixed_terms(out, pos):
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-    nelec = pos.shape[1]//3
-    k = 0
-
-    for ielec in range(nelec):
-
-        ix = ielec*3
-        tmp = grad(jacob[:, ix], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, ix+1]
-        k = k + 1
-        hess[:, k] = tmp[:, ix+2]
-        k = k + 1
-
-        iy = ielec*3 + 1
-        tmp = grad(jacob[:, iy], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, iy+1]
-        k = k + 1
-
-    return hess
-
-
-class TestAOderivativesADF(unittest.TestCase):
-
+class TestAOderivativesADF(BaseTestAO.BaseTestAOderivatives):
     def setUp(self):
-
         # define the molecule
-        path_hdf5 = PATH_TEST / 'hdf5/C_adf_dzp.hdf5'
+        path_hdf5 = PATH_TEST / "hdf5/C_adf_dzp.hdf5"
         self.mol = Molecule(load=path_hdf5)
 
         # define the wave function
-        self.wf = SlaterJastrow(self.mol, include_all_mo=True)
+        self.ao = AtomicOrbitals(self.mol)
 
         # define the grid points
         npts = 11
@@ -93,49 +24,10 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_ao_deriv(self):
-
-        ao = self.wf.ao(self.pos)
-        dao = self.wf.ao(self.pos, derivative=1)
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
-
-        gradcheck(self.wf.ao, self.pos)
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
-
-    def test_ao_grad_sum(self):
-
-        ao = self.wf.ao(self.pos)
-        dao_sum = self.wf.ao(self.pos, derivative=1, sum_grad=True)
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-
-        assert(torch.allclose(dao_sum, dao.sum(-1)))
-
-    def test_ao_hess(self):
-
-        ao = self.wf.ao(self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=2)
-        d2ao_grad = hess(ao, self.pos)
-        assert(torch.allclose(d2ao.sum(), d2ao_grad.sum()))
-
-    def test_ao_hess_sum(self):
-
-        ao = self.wf.ao(self.pos)
-        d2ao_sum = self.wf.ao(self.pos, derivative=2, sum_hess=True)
-        d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
-        assert(torch.allclose(d2ao_sum, d2ao.sum(-1)))
-
-    def test_ao_mixed_der(self):
-        ao = self.wf.ao(self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=3)
-        d2ao_auto = hess_mixed_terms(ao, self.pos)
-        assert(torch.allclose(d2ao.sum(), d2ao_auto.sum()))
-
 
 if __name__ == "__main__":
-    # unittest.main()
-
-    t = TestAOderivativesADF()
-    t.setUp()
-    t.test_ao_deriv()
-    t.test_ao_hess()
+    unittest.main()
+    # t = TestAOderivativesADF()
+    # t.setUp()
+    # t.test_ao_deriv()
+    # t.test_ao_hess()
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
index f152664a..cf9ac4cf 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
@@ -1,99 +1,27 @@
 import unittest
 import numpy as np
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
-
+from torch.autograd import Variable
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 from qmctorch.utils import set_torch_double_precision
+from .base_test_ao import BaseTestAO
 
 set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-def hess_mixed_terms(out, pos):
-
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-    nelec = pos.shape[1]//3
-    k = 0
-
-    for ielec in range(nelec):
-
-        ix = ielec*3
-        tmp = grad(jacob[:, ix], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, ix+1]
-        k = k + 1
-        hess[:, k] = tmp[:, ix+2]
-        k = k + 1
-
-        iy = ielec*3 + 1
-        tmp = grad(jacob[:, iy], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, iy+1]
-        k = k + 1
-
-    return hess
-
-
-class TestAOderivativesPyscf(unittest.TestCase):
-
+class TestAOderivativesPyscf(BaseTestAO.BaseTestAOderivatives):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
         # define the molecule
-        at = 'Li 0 0 0; H 0 0 1'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
-
-        self.m = gto.M(atom=at, basis=basis, unit='bohr')
+        at = "Li 0 0 0; H 0 0 1"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
-        # define the wave function
-        self.wf = SlaterJastrow(self.mol, include_all_mo=True)
+        # define the aos
+        self.ao = AtomicOrbitals(self.mol)
 
         # define the grid points
         npts = 11
@@ -101,64 +29,13 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-    def test_ao_deriv(self):
-
-        ao = self.wf.ao(self.pos)
-        dao = self.wf.ao(self.pos, derivative=1)
-
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
-
-        gradcheck(self.wf.ao, self.pos)
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
-
-    def test_ao_grad_sum(self):
-
-        ao = self.wf.ao(self.pos)
-        dao_sum = self.wf.ao(self.pos, derivative=1, sum_grad=True)
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-
-        assert(torch.allclose(dao_sum, dao.sum(-1)))
-
-    def test_ao_hess(self):
-
-        ao = self.wf.ao(self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=2)
-        d2ao_grad = hess(ao, self.pos)
-        assert(torch.allclose(d2ao.sum(), d2ao_grad.sum()))
-
-    def test_ao_hess_sum(self):
-
-        ao = self.wf.ao(self.pos)
-        d2ao_sum = self.wf.ao(self.pos, derivative=2, sum_hess=True)
-        d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
-        assert(torch.allclose(d2ao_sum, d2ao.sum(-1)))
-
-    def test_ao_mixed_der(self):
-        ao = self.wf.ao(self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=3)
-        d2ao_auto = hess_mixed_terms(ao, self.pos)
-
-        assert(torch.allclose(d2ao.sum(), d2ao_auto.sum()))
-
-    def test_ao_all(self):
-        ao = self.wf.ao(self.pos)
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-        d2ao = self.wf.ao(self.pos, derivative=2)
-        ao_all, dao_all, d2ao_all = self.wf.ao(
-            self.pos, derivative=[0, 1, 2])
-
-        assert(torch.allclose(ao, ao_all))
-        assert(torch.allclose(dao, dao_all))
-        assert(torch.allclose(d2ao, d2ao_all))
-
 
 if __name__ == "__main__":
-    # unittest.main()
+    unittest.main()
 
-    t = TestAOderivativesPyscf()
-    t.setUp()
-    t.test_ao_mixed_der()
+    # t = TestAOderivativesPyscf()
+    # t.setUp()
+    # t.test_ao_mixed_der()
     # t.test_ao_all()
     # t.test_ao_deriv()
     # t.test_ao_hess()
diff --git a/tests/wavefunction/orbitals/test_ao_values_adf.py b/tests/wavefunction/orbitals/test_ao_values_adf.py
index 6ba58a18..774159f7 100644
--- a/tests/wavefunction/orbitals/test_ao_values_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_adf.py
@@ -1,4 +1,5 @@
 import os
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 import unittest
 
 import matplotlib.pyplot as plt
@@ -7,7 +8,7 @@
 from torch.autograd import Variable
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+
 
 from ...path_utils import PATH_TEST
 
@@ -15,11 +16,11 @@
 
 
 def read_cubefile(fname):
-    with open(fname, 'r') as f:
+    with open(fname, "r") as f:
         data = f.readlines()
     vals = []
     for d in data[7:]:
-        vals.append(float(d.split('\n')[0]))
+        vals.append(float(d.split("\n")[0]))
     return vals
 
 
@@ -32,56 +33,50 @@ def get_pts(npts):
 
 
 def generate_cube_files(t21file):
-
     nao = create_ao_variable_in_t21(t21file)
     create_densf_input_file(t21file, nao)
-    os.system('$ADFBIN/densf < densf_input')
+    os.system("$ADFBIN/densf < densf_input")
 
 
 def create_ao_variable_in_t21(t21file):
-
     from scm import plams
+
     with plams.kFFile(t21file) as kf:
-        nao = kf.read('Basis', 'naos')
+        nao = kf.read("Basis", "naos")
         for iao in range(nao):
-
-            var = [0.] * nao
-            var[iao] = 1.
-            name = 'AO%d' % iao
-            kf.write('Basis', name, var)
+            var = [0.0] * nao
+            var[iao] = 1.0
+            name = "AO%d" % iao
+            kf.write("Basis", name, var)
 
     return nao
 
 
 def create_densf_input_file(t21name, nao):
+    f = open("densf_input", "w")
+    f.write("INPUTFILE %s\n\nCUBOUTPUT C_AO_\n\n" % t21name)
 
-    f = open('densf_input', 'w')
-    f.write('INPUTFILE %s\n\nCUBOUTPUT C_AO_\n\n' % t21name)
+    f.write("GRID \n")
+    f.write(" -1 -1 0\n")
+    f.write(" 21 21\n")
+    f.write(" 1 0 0 2\n")
+    f.write(" 0 1 0 2\n")
+    f.write("END\n\n")
 
-    f.write('GRID \n')
-    f.write(' -1 -1 0\n')
-    f.write(' 21 21\n')
-    f.write(' 1 0 0 2\n')
-    f.write(' 0 1 0 2\n')
-    f.write('END\n\n')
-
-    f.write('Orbitals GenBas\n')
+    f.write("Orbitals GenBas\n")
     for orb_index in range(nao):
-        f.write('  Basis%%AO%d\n' % orb_index)
-    f.write('End\n\n')
+        f.write("  Basis%%AO%d\n" % orb_index)
+    f.write("End\n\n")
 
 
 class TestAOvaluesADF(unittest.TestCase):
-
     def setUp(self):
-
         # define the molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/C_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/C_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
         # define the wave function
-        self.wf = SlaterJastrow(self.mol, include_all_mo=True)
+        self.ao = AtomicOrbitals(self.mol)
 
         # define the grid points
         self.npts = 21
@@ -93,17 +88,13 @@ def setUp(self):
         self.pos.requires_grad = True
 
     def test_ao(self):
-
-        aovals = self.wf.ao(self.pos).detach().numpy()
+        aovals = self.ao(self.pos).detach().numpy()
 
         for iorb in range(self.mol.basis.nao):
-
-            path_cube = PATH_TEST / f'cube/C_AO_%Basis%AO{iorb}.cub'
+            path_cube = PATH_TEST / f"cube/C_AO_%Basis%AO{iorb}.cub"
             fname = path_cube.absolute().as_posix()
-            adf_ref_data = np.array(read_cubefile(
-                fname)).reshape(self.npts, self.npts)
-            qmctorch_data = (aovals[:, 0, iorb]).reshape(
-                self.npts, self.npts)
+            adf_ref_data = np.array(read_cubefile(fname)).reshape(self.npts, self.npts)
+            qmctorch_data = (aovals[:, 0, iorb]).reshape(self.npts, self.npts)
 
             delta = np.abs(adf_ref_data - qmctorch_data)
 
@@ -118,7 +109,7 @@ def test_ao(self):
                 plt.imshow(delta)
                 plt.show()
 
-            assert(delta.mean() < 1E-3)
+            assert delta.mean() < 1e-3
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_ao_values_pyscf.py b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
index cc941a56..a4c6642e 100644
--- a/tests/wavefunction/orbitals/test_ao_values_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
@@ -7,27 +7,22 @@
 from torch.autograd import Variable
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 
 __PLOT__ = False
 
 
 class TestAOvaluesPyscf(unittest.TestCase):
-
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
-        self.m = gto.M(atom=at, basis=basis, unit='bohr')
+        self.m = gto.M(atom=at, basis=basis, unit="bohr")
 
         # define the wave function
-        self.wf = SlaterJastrow(self.mol)
+        self.ao = AtomicOrbitals(self.mol)
 
         self.pos = torch.zeros(100, self.mol.nelec * 3)
 
@@ -41,44 +36,36 @@ def setUp(self):
         self.x = self.pos[:, 0].detach().numpy()
 
     def test_ao(self):
-
         nzlm = np.linalg.norm(self.m.cart2sph_coeff(), axis=1)
 
-        aovals = self.wf.ao(self.pos).detach().numpy()/nzlm
-        aovals_ref = self.m.eval_ao('GTOval_cart',
-                                    self.pos.detach().numpy()[:, :3])
+        aovals = self.ao(self.pos).detach().numpy() / nzlm
+        aovals_ref = self.m.eval_ao("GTOval_cart", self.pos.detach().numpy()[:, :3])
 
         for iorb in range(self.mol.basis.nao):
-
             if __PLOT__:
-
                 plt.plot(self.x, aovals[:, 0, iorb])
                 plt.plot(self.x, aovals_ref[:, iorb])
                 plt.show()
 
-            assert np.allclose(
-                aovals[:, 0, iorb], aovals_ref[:, iorb])
+            assert np.allclose(aovals[:, 0, iorb], aovals_ref[:, iorb])
 
     def test_ao_deriv(self):
-
         nzlm = np.linalg.norm(self.m.cart2sph_coeff(), axis=1)
 
-        daovals = self.wf.ao(
-            self.pos, derivative=1).detach().numpy()/nzlm
+        daovals = self.ao(self.pos, derivative=1).detach().numpy() / nzlm
 
         daovals_ref = self.m.eval_gto(
-            'GTOval_ip_cart', self.pos.detach().numpy()[:, :3])
+            "GTOval_ip_cart", self.pos.detach().numpy()[:, :3]
+        )
         daovals_ref = daovals_ref.sum(0)
 
         for iorb in range(self.mol.basis.nao):
-
             if __PLOT__:
                 plt.plot(self.x, daovals[:, 0, iorb])
                 plt.plot(self.x, daovals_ref[:, iorb])
                 plt.show()
 
-            assert np.allclose(
-                daovals[:, 0, iorb], daovals_ref[:, iorb])
+            assert np.allclose(daovals[:, 0, iorb], daovals_ref[:, iorb])
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
index a38be2f0..9dea37e2 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -1,12 +1,15 @@
 import unittest
 
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
+from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import (
+    AtomicOrbitalsBackFlow,
+)
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
 set_torch_double_precision()
@@ -16,24 +19,18 @@
 
 
 def hess(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -41,43 +38,34 @@ def hess(out, pos):
 
 
 def hess_single_element(out, inp):
-
     shape = out.shape
     out = out.reshape(-1, 1)
 
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape))
 
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
+    hess = grad(jacob, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     return hess.reshape(*shape)
 
 
 class TestBFAOderivativesPyscf(unittest.TestCase):
-
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
+
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # define the wave function
-        self.ao = AtomicOrbitalsBackFlow(
-            self.mol, BackFlowKernelInverse)
+        self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
 
         # define the grid points
         self.npts = 11
@@ -92,53 +80,48 @@ def test_ao_gradian(self):
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1, sum_grad=False)
 
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
+        dao_grad = grad(ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
 
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
+        assert torch.allclose(dao.sum(), dao_grad.sum())
 
         dao = dao.sum(-1).sum(-1)
         dao_grad = dao_grad.T
-        assert(torch.allclose(dao, dao_grad))
+        assert torch.allclose(dao, dao_grad)
 
     def test_ao_jacobian(self):
-
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1)
 
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
+        dao_grad = grad(ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
 
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
+        assert torch.allclose(dao.sum(), dao_grad.sum())
 
         dao = dao.sum(-1).sum(-1)
         dao_grad = dao_grad.reshape(-1, self.ao.nelec, 3).sum(-1)
         dao_grad = dao_grad.T
-        assert(torch.allclose(dao, dao_grad))
+        assert torch.allclose(dao, dao_grad)
 
     def test_ao_hess(self):
-
         ao = self.ao(self.pos)
         d2ao = self.ao(self.pos, derivative=2)
 
         d2ao_grad = hess(ao, self.pos)
-        assert(torch.allclose(d2ao.sum(), d2ao_grad.sum()))
+        assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
 
         d2ao = d2ao.sum(-1).sum(-1)
         d2ao_grad = d2ao_grad.reshape(-1, self.ao.nelec, 3).sum(-1)
         d2ao_grad = d2ao_grad.T
-        assert(torch.allclose(d2ao, d2ao_grad))
+        assert torch.allclose(d2ao, d2ao_grad)
 
     def test_all_ao_values(self):
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1, sum_grad=False)
         d2ao = self.ao(self.pos, derivative=2, sum_hess=False)
-        ao_all, dao_all, d2ao_all = self.ao(
-            self.pos, derivative=[0, 1, 2])
+        ao_all, dao_all, d2ao_all = self.ao(self.pos, derivative=[0, 1, 2])
 
-        assert(torch.allclose(ao, ao_all))
-        assert(torch.allclose(dao, dao_all))
-        assert(torch.allclose(d2ao, d2ao_all))
+        assert torch.allclose(ao, ao_all)
+        assert torch.allclose(dao, dao_all)
+        assert torch.allclose(d2ao, d2ao_all)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics.py b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
index ccc1c754..32ae5214 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -1,6 +1,5 @@
 import unittest
 
-import numpy as np
 import torch
 from torch.autograd import grad, Variable
 
@@ -8,24 +7,18 @@
 
 
 def hess(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -33,113 +26,98 @@ def hess(out, pos):
 
 
 def hess_mixed_terms(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
-    nelec = pos.shape[1]//3
+    nelec = pos.shape[1] // 3
     k = 0
 
     for ielec in range(nelec):
+        ix = ielec * 3
+        tmp = grad(
+            jacob[:, ix], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
-        ix = ielec*3
-        tmp = grad(jacob[:, ix], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, ix+1]
+        hess[:, k] = tmp[:, ix + 1]
         k = k + 1
-        hess[:, k] = tmp[:, ix+2]
+        hess[:, k] = tmp[:, ix + 2]
         k = k + 1
 
-        iy = ielec*3 + 1
-        tmp = grad(jacob[:, iy], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        iy = ielec * 3 + 1
+        tmp = grad(
+            jacob[:, iy], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
-        hess[:, k] = tmp[:, iy+1]
+        hess[:, k] = tmp[:, iy + 1]
         k = k + 1
 
     return hess
 
 
 class TestCartesianHarmonics(unittest.TestCase):
-
     def setUp(self):
         bas_kx = torch.as_tensor([0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1])
         bas_ky = torch.as_tensor([0, 0, 1, 0, 0, 2, 0, 1, 1, 0, 1])
         bas_kz = torch.as_tensor([0, 0, 0, 1, 0, 0, 2, 0, 1, 1, 1])
         self.nbas = len(bas_kx)
 
-        self.harmonics = Harmonics(
-            'cart', bas_kx=bas_kx, bas_ky=bas_ky, bas_kz=bas_kz)
+        self.harmonics = Harmonics("cart", bas_kx=bas_kx, bas_ky=bas_ky, bas_kz=bas_kz)
 
         self.nbatch = 10
         self.nelec = 4
 
-        self.pos = Variable(torch.rand(self.nbatch, self.nelec*3))
+        self.pos = Variable(torch.rand(self.nbatch, self.nelec * 3))
         self.pos.requires_grad = True
 
     def process_position(self):
         """Return the distance between electron and centers."""
 
         bas_coords = torch.zeros(self.nbas, 3)
-        xyz = (self.pos.view(-1, self.nelec, 1, 3) -
-               bas_coords[None, ...])
-        r = torch.sqrt((xyz*xyz).sum(3))
+        xyz = self.pos.view(-1, self.nelec, 1, 3) - bas_coords[None, ...]
+        r = torch.sqrt((xyz * xyz).sum(3))
         return xyz, r
 
     def test_value(self):
-        xyz, r = self.process_position()
+        xyz, _ = self.process_position()
         self.harmonics(xyz, derivative=0)
 
     def test_grad(self):
-        xyz, r = self.process_position()
+        xyz, _ = self.process_position()
 
-        val_grad = self.harmonics(
-            xyz, derivative=1, sum_grad=False)
+        val_grad = self.harmonics(xyz, derivative=1, sum_grad=False)
 
         val = self.harmonics(xyz)
         val_grad_auto = grad(val, self.pos, torch.ones_like(val))[0]
 
-        assert(torch.allclose(
-            val_grad.sum(), val_grad_auto.sum(), atol=1E-6))
+        assert torch.allclose(val_grad.sum(), val_grad_auto.sum(), atol=1e-6)
 
     def test_jac(self):
-        xyz, r = self.process_position()
+        xyz, _ = self.process_position()
         val_jac = self.harmonics(xyz, derivative=1, sum_grad=True)
         val = self.harmonics(xyz)
         val_jac_auto = grad(val, self.pos, torch.ones_like(val))[0]
 
-        assert(torch.allclose(
-            val_jac.sum(), val_jac_auto.sum(), atol=1E-6))
+        assert torch.allclose(val_jac.sum(), val_jac_auto.sum(), atol=1e-6)
 
     def test_lap(self):
-        xyz, r = self.process_position()
+        xyz, _ = self.process_position()
         val_hess = self.harmonics(xyz, derivative=2)
         val = self.harmonics(xyz)
         val_hess_auto = hess(val, self.pos)
 
-        assert(torch.allclose(
-            val_hess.sum(), val_hess_auto.sum(), atol=1E-6))
+        assert torch.allclose(val_hess.sum(), val_hess_auto.sum(), atol=1e-6)
 
     def test_mixed_der(self):
-        xyz, r = self.process_position()
+        xyz, _ = self.process_position()
         val_hess = self.harmonics(xyz, derivative=3)
         val = self.harmonics(xyz)
         val_hess_auto = hess_mixed_terms(val, self.pos)
 
-        assert(torch.allclose(
-            val_hess.sum(), val_hess_auto.sum(), atol=1E-6))
+        assert torch.allclose(val_hess.sum(), val_hess_auto.sum(), atol=1e-6)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
index e58463d1..3a725d4b 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -4,38 +4,31 @@
 import torch
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 
 from ...path_utils import PATH_TEST
 from .second_derivative import second_derivative
 
 
 class TestCartesianHarmonicsADF(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/CO2_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/CO2_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='ground_state',
-                                include_all_mo=False)
+        self.ao = AtomicOrbitals(self.mol)
 
     def test_first_derivative_x(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 0] = torch.linspace(-4, 4, npts)
         self.dx = self.pos[1, 0] - self.pos[0, 0]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        xyz, _ = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -45,24 +38,22 @@ def test_first_derivative_x(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 0]
             dz_r0_fd = np.gradient(r0, self.dx)
-            delta = np.delete(np.abs(dz_r0-dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_y(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 1] = torch.linspace(-4, 4, npts)
         self.dy = self.pos[1, 1] - self.pos[0, 1]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        xyz, _ = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -72,46 +63,41 @@ def test_first_derivative_y(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 1]
             dz_r0_fd = np.gradient(r0, self.dy)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_z(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 2] = torch.linspace(-4, 4, npts)
         self.dz = self.pos[1, 2] - self.pos[0, 2]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        xyz, _ = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
         ielec = 0
 
         for iorb in range(7):
-
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 2]
             dz_r0_fd = np.gradient(r0, self.dz)
-            delta = np.delete(np.abs(dz_r0-dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(r0)
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
-
-    def test_laplacian(self, eps=1E-4):
+            assert np.all(delta < 1e-3)
 
+    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
@@ -132,12 +118,10 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 13] = -eps
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR, d2R = self.wf.ao.harmonics(
-            xyz, derivative=[0, 1, 2], sum_grad=False)
+        xyz, _ = self.ao._process_position(self.pos)
+        R, _, d2R = self.ao.harmonics(xyz, derivative=[0, 1, 2], sum_grad=False)
 
         for iorb in range(7):
-
             lap_analytic = np.zeros(npts - 2)
             lap_fd = np.zeros(npts - 2)
 
@@ -145,8 +129,8 @@ def test_laplacian(self, eps=1E-4):
                 lap_analytic[i - 1] = d2R[i, 0, iorb]
 
                 r0 = R[i, 0, iorb].detach().numpy()
-                rpz = R[i+1, 0, iorb].detach().numpy()
-                rmz = R[i-1, 0, iorb].detach().numpy()
+                rpz = R[i + 1, 0, iorb].detach().numpy()
+                rmz = R[i - 1, 0, iorb].detach().numpy()
                 d2z = second_derivative(rmz, r0, rpz, eps)
 
                 r0 = R[i, 0, iorb]
@@ -159,12 +143,11 @@ def test_laplacian(self, eps=1E-4):
                 rmy = R[i, 4, iorb]
                 d2y = second_derivative(rmy, r0, rpy, eps)
 
-                lap_fd[i-1] = d2x + d2y + d2z
+                lap_fd[i - 1] = d2x + d2y + d2z
 
-            delta = np.delete(
-                np.abs(lap_analytic - lap_fd), np.s_[450:550])
+            delta = np.delete(np.abs(lap_analytic - lap_fd), np.s_[450:550])
 
-            assert(np.all(delta < 5E-3))
+            assert np.all(delta < 5e-3)
 
             # plt.plot(lap_analytic, linewidth=2)
             # plt.plot(lap_fd)
@@ -173,14 +156,12 @@ def test_laplacian(self, eps=1E-4):
     def test_lap_sum(self):
         npts = 100
         self.pos = torch.rand(npts, self.mol.nelec * 3)
-        xyz, r = self.wf.ao._process_position(self.pos)
-        d2R_sum = self.wf.ao.harmonics(
-            xyz, derivative=2, sum_hess=True)
+        xyz, _ = self.ao._process_position(self.pos)
+        d2R_sum = self.ao.harmonics(xyz, derivative=2, sum_hess=True)
 
-        d2R = self.wf.ao.harmonics(
-            xyz, derivative=2, sum_hess=False)
+        d2R = self.ao.harmonics(xyz, derivative=2, sum_hess=False)
 
-        assert(torch.allclose(d2R.sum(-1), d2R_sum))
+        assert torch.allclose(d2R.sum(-1), d2R_sum)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_mo_values_adf.py b/tests/wavefunction/orbitals/test_mo_values_adf.py
index 5bb06c14..8bd5761e 100644
--- a/tests/wavefunction/orbitals/test_mo_values_adf.py
+++ b/tests/wavefunction/orbitals/test_mo_values_adf.py
@@ -7,7 +7,7 @@
 from torch.autograd import Variable
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 from ...path_utils import PATH_TEST
 
@@ -15,11 +15,11 @@
 
 
 def read_cubefile(fname):
-    with open(fname, 'r') as f:
+    with open(fname, "r") as f:
         data = f.readlines()
     vals = []
     for d in data[7:]:
-        vals.append(float(d.split('\n')[0]))
+        vals.append(float(d.split("\n")[0]))
     return vals
 
 
@@ -33,34 +33,30 @@ def get_pts(npts):
 
 def generate_cube_files(t21file, npts):
     create_densf_input_file(t21file, npts)
-    os.system('$ADFBIN/densf < densf_input')
+    os.system("$ADFBIN/densf < densf_input")
 
 
 def create_densf_input_file(t21name, npts):
+    f = open("densf_input", "w")
+    f.write("INPUTFILE %s\n\nCUBOUTPUT MO_\n\n" % t21name)
 
-    f = open('densf_input', 'w')
-    f.write('INPUTFILE %s\n\nCUBOUTPUT MO_\n\n' % t21name)
+    f.write("GRID \n")
+    f.write(" -1 -1 0\n")
+    f.write(" %d %d\n" % (npts, npts))
+    f.write(" 1 0 0 2\n")
+    f.write(" 0 1 0 2\n")
+    f.write("END\n\n")
 
-    f.write('GRID \n')
-    f.write(' -1 -1 0\n')
-    f.write(' %d %d\n' % (npts, npts))
-    f.write(' 1 0 0 2\n')
-    f.write(' 0 1 0 2\n')
-    f.write('END\n\n')
-
-    f.write('Orbitals SCF\n')
-    f.write('    A occ\n')
-    f.write('    A virt\n')
-    f.write('End\n\n')
+    f.write("Orbitals SCF\n")
+    f.write("    A occ\n")
+    f.write("    A virt\n")
+    f.write("End\n\n")
 
 
 class TestMOvaluesADF(unittest.TestCase):
-
     def setUp(self):
-
         # define the molecule
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/C_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/C_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
         # define the wave function
@@ -70,22 +66,21 @@ def setUp(self):
         self.npts = 21
         pts = get_pts(self.npts)
 
-        self.pos = 10 * torch.ones(self.npts ** 2, self.mol.nelec * 3)
+        self.pos = 10 * torch.ones(self.npts**2, self.mol.nelec * 3)
         self.pos[:, :3] = pts
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
     def test_mo(self):
-
-        movals = self.wf.mo_scf(self.wf.ao(self.pos)).detach().numpy()
+        movals = self.wf.mo(self.wf.ao(self.pos)).detach().numpy()
 
         for iorb in range(self.mol.basis.nmo):
-            path_cube = PATH_TEST / f'cube/C_MO_%SCF_A%{iorb + 1}.cub'
+            path_cube = PATH_TEST / f"cube/C_MO_%SCF_A%{iorb + 1}.cub"
             fname = path_cube.absolute().as_posix()
-            adf_ref_data = np.array(read_cubefile(
-                fname)).reshape(self.npts, self.npts)**2
-            qmctorch_data = (movals[:, 0, iorb]).reshape(
-                self.npts, self.npts)**2
+            adf_ref_data = (
+                np.array(read_cubefile(fname)).reshape(self.npts, self.npts) ** 2
+            )
+            qmctorch_data = (movals[:, 0, iorb]).reshape(self.npts, self.npts) ** 2
 
             delta = np.abs(adf_ref_data - qmctorch_data)
 
@@ -103,7 +98,7 @@ def test_mo(self):
             # the 0,0 point is much larger due to num instabilities
             delta = np.sort(delta.flatten())
             delta = delta[:-1]
-            assert(delta.mean() < 1E-3)
+            assert delta.mean() < 1e-3
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_norm.py b/tests/wavefunction/orbitals/test_norm.py
index 31ee1f11..6947e713 100644
--- a/tests/wavefunction/orbitals/test_norm.py
+++ b/tests/wavefunction/orbitals/test_norm.py
@@ -6,32 +6,28 @@
 
 
 class TestAtomicOrbitalNorm(unittest.TestCase):
-
     def test_sph_sto(self):
-
         basis = SimpleNamespace()
-        basis.harmonics_type = 'sph'
-        basis.radial_type = 'sto'
+        basis.harmonics_type = "sph"
+        basis.radial_type = "sto"
         basis.bas_n = torch.as_tensor([0, 1, 2])
         basis.bas_exp = torch.rand(3)
 
         atomic_orbital_norm(basis)
 
     def test_sph_gto(self):
-
         basis = SimpleNamespace()
-        basis.harmonics_type = 'sph'
-        basis.radial_type = 'gto'
+        basis.harmonics_type = "sph"
+        basis.radial_type = "gto"
         basis.bas_n = torch.as_tensor([0, 1, 2])
         basis.bas_exp = torch.rand(3)
 
         atomic_orbital_norm(basis)
 
     def test_cart_sto(self):
-
         basis = SimpleNamespace()
-        basis.harmonics_type = 'cart'
-        basis.radial_type = 'sto'
+        basis.harmonics_type = "cart"
+        basis.radial_type = "sto"
         basis.bas_exp = np.random.rand(4)
         basis.bas_kx = np.array([0, 0, 0, 1])
         basis.bas_ky = np.array([0, 1, 0, 0])
@@ -41,10 +37,9 @@ def test_cart_sto(self):
         atomic_orbital_norm(basis)
 
     def test_cart_gto(self):
-
         basis = SimpleNamespace()
-        basis.harmonics_type = 'cart'
-        basis.radial_type = 'gto'
+        basis.harmonics_type = "cart"
+        basis.radial_type = "gto"
         basis.bas_exp = np.random.rand(4)
         basis.bas_kx = np.array([0, 0, 0, 1])
         basis.bas_ky = np.array([0, 1, 0, 0])
diff --git a/tests/wavefunction/orbitals/test_orbital_dependent_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_orbital_dependent_backflow_ao_derivatives_pyscf.py
index 94d91474..db3d6db7 100644
--- a/tests/wavefunction/orbitals/test_orbital_dependent_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_orbital_dependent_backflow_ao_derivatives_pyscf.py
@@ -1,12 +1,15 @@
 import unittest
 
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.wavefunction.orbitals.atomic_orbitals_orbital_dependent_backflow import AtomicOrbitalsOrbitalDependentBackFlow
+from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import (
+    AtomicOrbitalsBackFlow,
+)
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
 set_torch_double_precision()
@@ -16,24 +19,18 @@
 
 
 def hess(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -41,43 +38,35 @@ def hess(out, pos):
 
 
 def hess_single_element(out, inp):
-
     shape = out.shape
     out = out.reshape(-1, 1)
 
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, inp,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape))
 
-    hess = grad(jacob, inp,
-                grad_outputs=z,
-                only_inputs=True,
-                create_graph=True)[0]
+    hess = grad(jacob, inp, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     return hess.reshape(*shape)
 
 
 class TestODBFAOderivativesPyscf(unittest.TestCase):
-
     def setUp(self):
-
         # define the molecule
-        at = 'C 0 0 0'
-        basis = 'dzp'
-        self.mol = Molecule(atom=at,
-                            calculator='pyscf',
-                            basis=basis,
-                            unit='bohr')
+        at = "C 0 0 0"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the wave function
-        self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-            self.mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
+
+        # define the wave function
+        self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
 
         # change the weights
         for ker in self.ao.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -96,53 +85,48 @@ def test_ao_gradian(self):
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1, sum_grad=False)
 
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
+        dao_grad = grad(ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
 
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
+        assert torch.allclose(dao.sum(), dao_grad.sum())
 
         dao = dao.sum(-1).sum(-1)
         dao_grad = dao_grad.T
-        assert(torch.allclose(dao, dao_grad))
+        assert torch.allclose(dao, dao_grad)
 
     def test_ao_jacobian(self):
-
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1)
 
-        dao_grad = grad(
-            ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
+        dao_grad = grad(ao, self.pos, grad_outputs=torch.ones_like(ao))[0]
 
-        assert(torch.allclose(dao.sum(), dao_grad.sum()))
+        assert torch.allclose(dao.sum(), dao_grad.sum())
 
         dao = dao.sum(-1).sum(-1)
         dao_grad = dao_grad.reshape(-1, self.ao.nelec, 3).sum(-1)
         dao_grad = dao_grad.T
-        assert(torch.allclose(dao, dao_grad))
+        assert torch.allclose(dao, dao_grad)
 
     def test_ao_hess(self):
-
         ao = self.ao(self.pos)
         d2ao = self.ao(self.pos, derivative=2)
 
         d2ao_grad = hess(ao, self.pos)
-        assert(torch.allclose(d2ao.sum(), d2ao_grad.sum()))
+        assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
 
         d2ao = d2ao.sum(-1).sum(-1)
         d2ao_grad = d2ao_grad.reshape(-1, self.ao.nelec, 3).sum(-1)
         d2ao_grad = d2ao_grad.T
-        assert(torch.allclose(d2ao, d2ao_grad))
+        assert torch.allclose(d2ao, d2ao_grad)
 
     def test_all_ao_values(self):
         ao = self.ao(self.pos)
         dao = self.ao(self.pos, derivative=1, sum_grad=False)
         d2ao = self.ao(self.pos, derivative=2, sum_hess=False)
-        ao_all, dao_all, d2ao_all = self.ao(
-            self.pos, derivative=[0, 1, 2])
+        ao_all, dao_all, d2ao_all = self.ao(self.pos, derivative=[0, 1, 2])
 
-        assert(torch.allclose(ao, ao_all))
-        assert(torch.allclose(dao, dao_all))
-        assert(torch.allclose(d2ao, d2ao_all))
+        assert torch.allclose(ao, ao_all)
+        assert torch.allclose(dao, dao_all)
+        assert torch.allclose(d2ao, d2ao_all)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_radial_functions.py b/tests/wavefunction/orbitals/test_radial_functions.py
index a722a88f..b94c451d 100644
--- a/tests/wavefunction/orbitals/test_radial_functions.py
+++ b/tests/wavefunction/orbitals/test_radial_functions.py
@@ -1,31 +1,27 @@
 import unittest
-from qmctorch.wavefunction.orbitals.radial_functions import (radial_gaussian_pure,
-                                                             radial_gaussian,
-                                                             radial_slater,
-                                                             radial_slater_pure)
+from qmctorch.wavefunction.orbitals.radial_functions import (
+    radial_gaussian_pure,
+    radial_gaussian,
+    radial_slater,
+    radial_slater_pure,
+)
 import torch
 from torch.autograd import grad, Variable
 
 
 def hess(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
 
     for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        tmp = grad(
+            jacob[:, idim], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
         hess[:, idim] = tmp[:, idim]
 
@@ -33,52 +29,46 @@ def hess(out, pos):
 
 
 def hess_mixed_terms(out, pos):
-
     # compute the jacobian
     z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+    jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
     # compute the diagonal element of the Hessian
     z = Variable(torch.ones(jacob.shape[0]))
     hess = torch.zeros(jacob.shape)
-    nelec = pos.shape[1]//3
+    nelec = pos.shape[1] // 3
     k = 0
 
     for ielec in range(nelec):
+        ix = ielec * 3
+        tmp = grad(
+            jacob[:, ix], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
-        ix = ielec*3
-        tmp = grad(jacob[:, ix], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, k] = tmp[:, ix+1]
+        hess[:, k] = tmp[:, ix + 1]
         k = k + 1
-        hess[:, k] = tmp[:, ix+2]
+        hess[:, k] = tmp[:, ix + 2]
         k = k + 1
 
-        iy = ielec*3 + 1
-        tmp = grad(jacob[:, iy], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+        iy = ielec * 3 + 1
+        tmp = grad(
+            jacob[:, iy], pos, grad_outputs=z, only_inputs=True, create_graph=True
+        )[0]
 
-        hess[:, k] = tmp[:, iy+1]
+        hess[:, k] = tmp[:, iy + 1]
         k = k + 1
 
     return hess
 
 
 class TestRadialFunctions(unittest.TestCase):
-
     def setUp(self):
-        self.radfn = [radial_gaussian,
-                      radial_gaussian_pure,
-                      radial_slater,
-                      radial_slater_pure]
+        self.radfn = [
+            radial_gaussian,
+            radial_gaussian_pure,
+            radial_slater,
+            radial_slater_pure,
+        ]
 
         self.nbatch = 10
         self.nelec = 4
@@ -87,21 +77,20 @@ def setUp(self):
         self.bas_n = torch.Tensor([0, 1, 1, 1, 2, 2])
         self.bas_exp = torch.rand(self.nbas)
 
-        self.xyz = Variable(torch.rand(self.nbatch, self.nelec*3))
+        self.xyz = Variable(torch.rand(self.nbatch, self.nelec * 3))
         self.xyz.requires_grad = True
 
     def process_position(self):
         """Return the distance between electron and centers."""
 
         bas_coords = torch.zeros(self.nbas, 3)
-        xyz = (self.xyz.view(-1, self.nelec, 1, 3) -
-               bas_coords[None, ...])
-        r = torch.sqrt((xyz*xyz).sum(3))
+        xyz = self.xyz.view(-1, self.nelec, 1, 3) - bas_coords[None, ...]
+        r = torch.sqrt((xyz * xyz).sum(3))
         return xyz, r
 
     def test_val(self):
         """Simply executes the kernel."""
-        xyz, r = self.process_position()
+        _, r = self.process_position()
         for fn in self.radfn:
             fn(r, self.bas_n, self.bas_exp)
 
@@ -109,56 +98,51 @@ def test_grad(self):
         """Compute the gradients of the radial function."""
 
         for fn in self.radfn:
-
             xyz, r = self.process_position()
             val = fn(r, self.bas_n, self.bas_exp)
-            val_grad_auto = grad(
-                val, self.xyz, torch.ones_like(val))[0]
+            val_grad_auto = grad(val, self.xyz, torch.ones_like(val))[0]
 
-            val_grad = fn(r, self.bas_n, self.bas_exp, xyz=xyz,
-                          derivative=1, sum_grad=False)
+            val_grad = fn(
+                r, self.bas_n, self.bas_exp, xyz=xyz, derivative=1, sum_grad=False
+            )
 
-            val_grad_sum = fn(r, self.bas_n, self.bas_exp, xyz=xyz,
-                              derivative=1, sum_grad=True)
+            val_grad_sum = fn(
+                r, self.bas_n, self.bas_exp, xyz=xyz, derivative=1, sum_grad=True
+            )
 
-            assert(torch.allclose(
-                val_grad.sum(), val_grad_auto.sum(), atol=1E-6))
+            assert torch.allclose(val_grad.sum(), val_grad_auto.sum(), atol=1e-6)
 
-            assert(torch.allclose(
-                val_grad.sum(-1), val_grad_sum, atol=1E-6))
+            assert torch.allclose(val_grad.sum(-1), val_grad_sum, atol=1e-6)
 
     def test_lap(self):
         """Computes the laplacian of the radial functions."""
 
         for fn in self.radfn:
-
             xyz, r = self.process_position()
             val = fn(r, self.bas_n, self.bas_exp)
 
-            val_lap = fn(r, self.bas_n, self.bas_exp, xyz=xyz,
-                         derivative=2, sum_hess=False)
-            val_lap_sum = fn(r, self.bas_n, self.bas_exp, xyz=xyz,
-                             derivative=2, sum_hess=True)
+            val_lap = fn(
+                r, self.bas_n, self.bas_exp, xyz=xyz, derivative=2, sum_hess=False
+            )
+            val_lap_sum = fn(
+                r, self.bas_n, self.bas_exp, xyz=xyz, derivative=2, sum_hess=True
+            )
 
             val_lap_auto = hess(val, self.xyz)
 
-            assert(torch.allclose(
-                val_lap.sum(-1), val_lap_sum, atol=1E-6))
+            assert torch.allclose(val_lap.sum(-1), val_lap_sum, atol=1e-6)
 
-            assert(torch.allclose(
-                val_lap.sum(), val_lap_auto.sum(), atol=1E-6))
+            assert torch.allclose(val_lap.sum(), val_lap_auto.sum(), atol=1e-6)
 
     def test_mixed(self):
         """Test the mixed second derivatives."""
         for fn in self.radfn:
             xyz, r = self.process_position()
             val = fn(r, self.bas_n, self.bas_exp)
-            val_lap = fn(r, self.bas_n, self.bas_exp, xyz=xyz,
-                         derivative=3)
+            val_lap = fn(r, self.bas_n, self.bas_exp, xyz=xyz, derivative=3)
 
         val_lap_auto = hess_mixed_terms(val, self.xyz)
-        assert(torch.allclose(
-            val_lap.sum(), val_lap_auto.sum(), atol=1E-6))
+        assert torch.allclose(val_lap.sum(), val_lap_auto.sum(), atol=1e-6)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/test_radial_gto.py b/tests/wavefunction/orbitals/test_radial_gto.py
index 680f08f9..19802c20 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -4,41 +4,40 @@
 import torch
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 from .second_derivative import second_derivative
 
 
 class TestRadialSlater(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        self.mol = Molecule(atom='C 0 0 0; O 0 0 2.190; O 0 0 -2.190',
-                            calculator='pyscf',
-                            basis='dzp',
-                            unit='bohr')
+        self.mol = Molecule(
+            atom="C 0 0 0; O 0 0 2.190; O 0 0 -2.190",
+            calculator="pyscf",
+            basis="dzp",
+            unit="bohr",
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='ground_state',
-                                include_all_mo=False)
+        self.ao = AtomicOrbitals(self.mol)
 
     def test_first_derivative_x(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 0] = torch.linspace(-4, 4, npts)
         self.dx = self.pos[1, 0] - self.pos[0, 0]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -48,28 +47,29 @@ def test_first_derivative_x(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 0]
             dz_r0_fd = np.gradient(r0, self.dx)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_y(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 1] = torch.linspace(-4, 4, npts)
         self.dy = self.pos[1, 1] - self.pos[0, 1]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -79,48 +79,46 @@ def test_first_derivative_y(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 1]
             dz_r0_fd = np.gradient(r0, self.dy)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_z(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 2] = torch.linspace(-4, 4, npts)
         self.dz = self.pos[1, 2] - self.pos[0, 2]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
         R = R.detach().numpy()
         dR = dR.detach().numpy()
         ielec = 0
 
         for iorb in range(7):
-
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 2]
             dz_r0_fd = np.gradient(r0, self.dz)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
-
-    def test_laplacian(self, eps=1E-4):
+            assert np.all(delta < 1e-3)
 
+    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         z = torch.linspace(-3, 3, npts)
@@ -140,15 +138,17 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 13] = -eps
         self.pos[:, 14] = z
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR, d2R = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                       self.wf.ao.bas_exp,
-                                       xyz=xyz,
-                                       derivative=[0, 1, 2],
-                                       sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, _, d2R = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2],
+            sum_grad=False,
+        )
 
         for iorb in range(7):
-
             lap_analytic = np.zeros(npts - 2)
             lap_fd = np.zeros(npts - 2)
 
@@ -156,8 +156,8 @@ def test_laplacian(self, eps=1E-4):
                 lap_analytic[i - 1] = d2R[i, 0, iorb]
 
                 r0 = R[i, 0, iorb].detach().numpy()
-                rpz = R[i+1, 0, iorb].detach().numpy()
-                rmz = R[i-1, 0, iorb].detach().numpy()
+                rpz = R[i + 1, 0, iorb].detach().numpy()
+                rmz = R[i - 1, 0, iorb].detach().numpy()
                 d2z = second_derivative(rmz, r0, rpz, eps)
 
                 r0 = R[i, 0, iorb]
@@ -173,10 +173,9 @@ def test_laplacian(self, eps=1E-4):
                 lap_fd[i - 1] = d2x + d2y + d2z
 
             m = np.abs(lap_analytic).max()
-            delta = np.delete(
-                np.abs(lap_analytic - lap_fd) / m, np.s_[450:550])
+            delta = np.delete(np.abs(lap_analytic - lap_fd) / m, np.s_[450:550])
 
-            assert(np.all(delta < 5E-3))
+            assert np.all(delta < 5e-3)
             # plt.plot(lap_analytic, linewidth=2)
             # plt.plot(lap_fd)
             # plt.show()
diff --git a/tests/wavefunction/orbitals/test_radial_sto.py b/tests/wavefunction/orbitals/test_radial_sto.py
index 8aacaa00..614ad256 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -4,42 +4,37 @@
 import torch
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 from ...path_utils import PATH_TEST
 from .second_derivative import second_derivative
 
-import matplotlib.pyplot as plt
-
 
 class TestRadialSlater(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
-        path_hdf5 = (
-            PATH_TEST / 'hdf5/CO2_adf_dzp.hdf5').absolute().as_posix()
+        path_hdf5 = (PATH_TEST / "hdf5/CO2_adf_dzp.hdf5").absolute().as_posix()
         self.mol = Molecule(load=path_hdf5)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='ground_state',
-                                include_all_mo=False)
+        self.ao = AtomicOrbitals(self.mol)
 
     def test_first_derivative_x(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 0] = torch.linspace(-4, 4, npts)
         self.dx = self.pos[1, 0] - self.pos[0, 0]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -49,28 +44,29 @@ def test_first_derivative_x(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 0]
             dz_r0_fd = np.gradient(r0, self.dx)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_y(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 1] = torch.linspace(-4, 4, npts)
         self.dy = self.pos[1, 1] - self.pos[0, 1]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -80,48 +76,46 @@ def test_first_derivative_y(self):
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 1]
             dz_r0_fd = np.gradient(r0, self.dy)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
+            assert np.all(delta < 1e-3)
 
     def test_first_derivative_z(self):
-
         npts = 1000
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
         self.pos[:, 2] = torch.linspace(-4, 4, npts)
         self.dz = self.pos[1, 2] - self.pos[0, 2]
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                  self.wf.ao.bas_exp,
-                                  xyz=xyz,
-                                  derivative=[0, 1],
-                                  sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1],
+            sum_grad=False,
+        )
         R = R.detach().numpy()
         dR = dR.detach().numpy()
         ielec = 0
 
         for iorb in range(7):
-
             r0 = R[:, ielec, iorb]
             dz_r0 = dR[:, ielec, iorb, 2]
             dz_r0_fd = np.gradient(r0, self.dz)
-            delta = np.delete(
-                np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
+            delta = np.delete(np.abs(dz_r0 - dz_r0_fd), np.s_[450:550])
 
             # plt.plot(dz_r0)
             # plt.plot(dz_r0_fd)
             # plt.show()
 
-            assert(np.all(delta < 1E-3))
-
-    def test_laplacian(self, eps=1E-4):
+            assert np.all(delta < 1e-3)
 
+    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
@@ -142,24 +136,26 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 13] = -eps
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
-        xyz, r = self.wf.ao._process_position(self.pos)
-        R, dR, d2R = self.wf.ao.radial(r, self.wf.ao.bas_n,
-                                       self.wf.ao.bas_exp,
-                                       xyz=xyz,
-                                       derivative=[0, 1, 2],
-                                       sum_grad=False)
+        xyz, r = self.ao._process_position(self.pos)
+        R, _, d2R = self.ao.radial(
+            r,
+            self.ao.bas_n,
+            self.ao.bas_exp,
+            xyz=xyz,
+            derivative=[0, 1, 2],
+            sum_grad=False,
+        )
 
         for iorb in range(7):
-
             lap_analytic = np.zeros(npts - 2)
             lap_fd = np.zeros(npts - 2)
 
             for i in range(1, npts - 1):
-                lap_analytic[i-1] = d2R[i, 0, iorb]
+                lap_analytic[i - 1] = d2R[i, 0, iorb]
 
                 r0 = R[i, 0, iorb].detach().numpy()
-                rpz = R[i+1, 0, iorb].detach().numpy()
-                rmz = R[i-1, 0, iorb].detach().numpy()
+                rpz = R[i + 1, 0, iorb].detach().numpy()
+                rmz = R[i - 1, 0, iorb].detach().numpy()
                 d2z = second_derivative(rmz, r0, rpz, eps)
 
                 r0 = R[i, 0, iorb]
@@ -172,12 +168,11 @@ def test_laplacian(self, eps=1E-4):
                 rmy = R[i, 4, iorb]
                 d2y = second_derivative(rmy, r0, rpy, eps)
 
-                lap_fd[i-1] = d2x + d2y + d2z
+                lap_fd[i - 1] = d2x + d2y + d2z
 
-            delta = np.delete(
-                np.abs(lap_analytic - lap_fd), np.s_[450:550])
+            delta = np.delete(np.abs(lap_analytic - lap_fd), np.s_[450:550])
 
-            assert(np.all(delta < 5E-3))
+            assert np.all(delta < 5e-3)
 
             # plt.plot(lap_analytic, linewidth=2)
             # plt.plot(lap_fd)
diff --git a/tests/wavefunction/orbitals/test_spherical_harmonics.py b/tests/wavefunction/orbitals/test_spherical_harmonics.py
index 4d6b3d4c..bb58bebe 100644
--- a/tests/wavefunction/orbitals/test_spherical_harmonics.py
+++ b/tests/wavefunction/orbitals/test_spherical_harmonics.py
@@ -1,18 +1,16 @@
 import unittest
 
-import numpy as np
 import torch
 
 from qmctorch.wavefunction.orbitals.spherical_harmonics import Harmonics
 
 
 class TestSphericalHarmonics(unittest.TestCase):
-
     def setUp(self):
         bas_l = torch.Tensor([0, 1, 1, 1, 2, 2, 2, 2, 2])
         bas_m = torch.Tensor([0, -1, 0, 1, -2, -1, 0, 1, 2])
 
-        self.harmonics = Harmonics('sph', bas_l=bas_l, bas_m=bas_m)
+        self.harmonics = Harmonics("sph", bas_l=bas_l, bas_m=bas_m)
         self.pos = torch.rand(5, 4, 9, 3)
 
     def test_value(self):
diff --git a/tests/wavefunction/pooling/__init__.py b/tests/wavefunction/pooling/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/pooling/test_orbconf.py b/tests/wavefunction/pooling/test_orbconf.py
index 3b5942e4..ef827b58 100644
--- a/tests/wavefunction/pooling/test_orbconf.py
+++ b/tests/wavefunction/pooling/test_orbconf.py
@@ -9,9 +9,7 @@
 
 
 class TestOrbitalConfiguration(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -19,19 +17,19 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='H 0 0 -0.69; H 0 0 0.69',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g')
+            atom="H 0 0 -0.69; H 0 0 0.69",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+        )
 
         self.orb_conf = OrbitalConfigurations(mol)
 
     def test_confs(self):
-
-        self.orb_conf.get_configs('ground_state')
-        self.orb_conf.get_configs('single(2,2)')
-        self.orb_conf.get_configs('single_double(2,2)')
-        self.orb_conf.get_configs('cas(2,2)')
+        self.orb_conf.get_configs("ground_state")
+        self.orb_conf.get_configs("single(2,2)")
+        self.orb_conf.get_configs("single_double(2,2)")
+        self.orb_conf.get_configs("cas(2,2)")
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/pooling/test_slater.py b/tests/wavefunction/pooling/test_slater.py
index d7df9766..dc18ba52 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -4,72 +4,78 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
 class TestSlater(unittest.TestCase):
-
     def setUp(self):
-
         set_torch_double_precision()
 
-        self.mol = Molecule(atom='C 0 0 0; O 0 0 2.173; O 0 0 -2.173',
-                            calculator='pyscf',
-                            basis='dzp',
-                            unit='bohr')
-
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single_double(6,6)',
-                                include_all_mo=False)
-
-        self.wf_allmo = SlaterJastrow(self.mol, kinetic='jacobi',
-                                      configs='single_double(6,6)',
-                                      include_all_mo=True)
+        self.mol = Molecule(
+            atom="C 0 0 0; O 0 0 2.173; O 0 0 -2.173",
+            calculator="pyscf",
+            basis="dzp",
+            unit="bohr",
+        )
+
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single_double(6,6)",
+            jastrow=jastrow,
+            include_all_mo=False,
+        )
+
+        self.wf_allmo = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single_double(6,6)",
+            jastrow=jastrow,
+            include_all_mo=True,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
         self.wf_allmo.fc.weight.data = self.random_fc_weight
 
     def test_det(self):
-
         mo = torch.rand(10, 22, 45)
         det_explicit = self.wf.pool.det_explicit(mo)
         det_single = self.wf.pool.det_single_double(mo)
-        assert(torch.allclose(det_explicit, det_single))
+        assert torch.allclose(det_explicit, det_single)
 
     def test_det_all_mo(self):
-
         mo = torch.rand(10, 22, 45)
         det_explicit = self.wf_allmo.pool.det_explicit(mo)
         det_single = self.wf_allmo.pool.det_single_double(mo)
-        assert(torch.allclose(det_explicit, det_single))
+        assert torch.allclose(det_explicit, det_single)
 
     def test_op(self):
-
         mo = torch.rand(10, 22, 45)
         bkin = torch.rand(10, 22, 45)
         kin_explicit = self.wf.pool.operator_explicit(mo, bkin)
         kin = self.wf.pool.operator_single_double(mo, bkin)
-        assert(torch.allclose(kin_explicit[0], kin[0]))
-        assert(torch.allclose(kin_explicit[1], kin[1]))
+        assert torch.allclose(kin_explicit[0], kin[0])
+        assert torch.allclose(kin_explicit[1], kin[1])
 
     def test_op_all_mo(self):
-
         mo = torch.rand(10, 22, 45)
         bkin = torch.rand(10, 22, 45)
         kin_explicit = self.wf_allmo.pool.operator_explicit(mo, bkin)
         kin = self.wf_allmo.pool.operator_single_double(mo, bkin)
-        assert(torch.allclose(kin_explicit[0], kin[0]))
-        assert(torch.allclose(kin_explicit[1], kin[1]))
+        assert torch.allclose(kin_explicit[0], kin[0])
+        assert torch.allclose(kin_explicit[1], kin[1])
 
     def test_multiple_ops(self):
-
         mo = torch.rand(10, 22, 45)
         bop = torch.rand(6, 10, 22, 45)
         op_explicit = self.wf_allmo.pool.operator_explicit(mo, bop)
         op = self.wf_allmo.pool.operator_single_double(mo, bop)
-        assert(torch.allclose(op_explicit[0], op[0]))
-        assert(torch.allclose(op_explicit[1], op[1]))
+        assert torch.allclose(op_explicit[0], op[0])
+        assert torch.allclose(op_explicit[1], op[1])
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/pooling/test_trace_trick.py b/tests/wavefunction/pooling/test_trace_trick.py
index 3f1282c5..33abb837 100644
--- a/tests/wavefunction/pooling/test_trace_trick.py
+++ b/tests/wavefunction/pooling/test_trace_trick.py
@@ -5,7 +5,8 @@
 from torch.autograd import Variable, grad
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
 def btrace(M):
@@ -14,7 +15,8 @@ def btrace(M):
 
 class OrbitalTest(SlaterJastrow):
     def __init__(self, mol):
-        super(OrbitalTest, self).__init__(mol)
+        jastrow = JastrowFactor(mol, PadeJastrowKernel)
+        super(OrbitalTest, self).__init__(mol, jastrow)
 
     def first_der_autograd(self, x):
         """Compute the first derivative of the AO using autograd
@@ -28,10 +30,7 @@ def first_der_autograd(self, x):
         out = self.ao(x)
 
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, x,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, x, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         return jacob
 
@@ -62,21 +61,21 @@ def second_der_autograd(self, pos, out=None):
 
         # compute the jacobian
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         # compute the diagonal element of the Hessian
         z = Variable(torch.ones(jacob.shape[0]))
         hess = torch.zeros(jacob.shape)
 
         for idim in range(jacob.shape[1]):
-            tmp = grad(jacob[:, idim], pos,
-                       grad_outputs=z,
-                       retain_graph=True,
-                       only_inputs=True,
-                       allow_unused=True)[0]
+            tmp = grad(
+                jacob[:, idim],
+                pos,
+                grad_outputs=z,
+                retain_graph=True,
+                only_inputs=True,
+                allow_unused=True,
+            )[0]
 
             hess[:, idim] = tmp[:, idim]
 
@@ -96,21 +95,21 @@ def second_der_autograd_mo(self, pos):
 
         # compute the jacobian
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         # compute the diagonal element of the Hessian
         z = Variable(torch.ones(jacob.shape[0]))
         hess = torch.zeros(jacob.shape)
 
         for idim in range(jacob.shape[1]):
-            tmp = grad(jacob[:, idim], pos,
-                       grad_outputs=z,
-                       retain_graph=True,
-                       only_inputs=True,
-                       allow_unused=True)[0]
+            tmp = grad(
+                jacob[:, idim],
+                pos,
+                grad_outputs=z,
+                retain_graph=True,
+                only_inputs=True,
+                allow_unused=True,
+            )[0]
 
             hess[:, idim] = tmp[:, idim]
 
@@ -132,7 +131,7 @@ def first_der_trace(self, x, dAO=None):
             dAO = self.ao(x, derivative=1)
         else:
             invAO = torch.inverse(AO)
-        return btrace(invAO@dAO)
+        return btrace(invAO @ dAO)
 
     def test_grad_autograd(self, pos):
         """Compute the jacobian of the AO block using autograd
@@ -148,10 +147,7 @@ def test_grad_autograd(self, pos):
 
         # compute the jacobian
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         return jacob.sum(1).view(-1, 1)
 
@@ -168,21 +164,21 @@ def test_hess_autograd(self, pos):
 
         # compute the jacobian
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         # compute the diagonal element of the Hessian
         z = Variable(torch.ones(jacob.shape[0]))
         hess = torch.zeros(jacob.shape[0])
 
         for idim in range(jacob.shape[1]):
-            tmp = grad(jacob[:, idim], pos,
-                       grad_outputs=z,
-                       retain_graph=True,
-                       only_inputs=True,
-                       allow_unused=True)[0]
+            tmp = grad(
+                jacob[:, idim],
+                pos,
+                grad_outputs=z,
+                retain_graph=True,
+                only_inputs=True,
+                allow_unused=True,
+            )[0]
 
             hess += tmp[:, idim]
 
@@ -205,21 +201,21 @@ def test_kin_autograd(self, pos):
 
         # compute the jacobian
         z = Variable(torch.ones(out.shape))
-        jacob = grad(out, pos,
-                     grad_outputs=z,
-                     only_inputs=True,
-                     create_graph=True)[0]
+        jacob = grad(out, pos, grad_outputs=z, only_inputs=True, create_graph=True)[0]
 
         # compute the diagonal element of the Hessian
         z = Variable(torch.ones(jacob.shape[0]))
         hess = torch.zeros(jacob.shape[0])
 
         for idim in range(jacob.shape[1]):
-            tmp = grad(jacob[:, idim], pos,
-                       grad_outputs=z,
-                       retain_graph=True,
-                       only_inputs=True,
-                       allow_unused=True)[0]
+            tmp = grad(
+                jacob[:, idim],
+                pos,
+                grad_outputs=z,
+                retain_graph=True,
+                only_inputs=True,
+                allow_unused=True,
+            )[0]
 
             hess += tmp[:, idim]
 
@@ -227,17 +223,16 @@ def test_kin_autograd(self, pos):
 
 
 class TestTrace(unittest.TestCase):
-
     def setUp(self):
-
-        atom_str = 'O 0 0 -0.69; C 0 0 0.69'
-        self.m = gto.M(atom=atom_str, basis='sto-3g', unit='bohr')
-        self.mol = Molecule(atom=atom_str, calculator='pyscf',
-                            basis='sto-3g', unit='bohr')
+        atom_str = "O 0 0 -0.69; C 0 0 0.69"
+        self.m = gto.M(atom=atom_str, basis="sto-3g", unit="bohr")
+        self.mol = Molecule(
+            atom=atom_str, calculator="pyscf", basis="sto-3g", unit="bohr"
+        )
 
         # define the wave function
         self.wf = OrbitalTest(self.mol)
-        self.x = 2 * torch.rand(5, 3 * self.mol.nelec) - 1.
+        self.x = 2 * torch.rand(5, 3 * self.mol.nelec) - 1.0
         self.x.requires_grad = True
 
     def test_ao_der(self):
@@ -245,20 +240,20 @@ def test_ao_der(self):
         dAO = self.wf.ao(self.x, derivative=1).sum()
         dAO_auto = self.wf.first_der_autograd(self.x).sum()
         print(dAO, dAO_auto)
-        assert(torch.allclose(dAO, dAO_auto))
+        assert torch.allclose(dAO, dAO_auto)
 
     def test_ao_2der(self):
         """Test the values of the AO 2nd derivative."""
         d2AO = self.wf.ao(self.x, derivative=2).sum()
         d2AO_auto = self.wf.second_der_autograd(self.x).sum()
         print(d2AO, d2AO_auto)
-        assert(torch.allclose(d2AO, d2AO_auto))
+        assert torch.allclose(d2AO, d2AO_auto)
 
     def test_mo_2der(self):
         """Test the values of the MO 2nd derivative."""
         d2MO = self.wf.mo(self.wf.ao(self.x, derivative=2)).sum()
         d2MO_auto = self.wf.second_der_autograd_mo(self.x).sum()
-        assert(torch.allclose(d2MO, d2MO_auto))
+        assert torch.allclose(d2MO, d2MO_auto)
 
     def test_trace(self):
         """Test the values jacobian and hessian with autograd and
@@ -270,12 +265,12 @@ def test_trace(self):
         d2AO = self.wf.ao(self.x, derivative=2)
 
         jac_auto = self.wf.test_grad_autograd(self.x)
-        jac_trace = btrace(iAO@dAO[:, :4, :4]) * torch.det(AO)
-        assert(torch.allclose(jac_auto.sum(), jac_trace.sum()))
+        jac_trace = btrace(iAO @ dAO[:, :4, :4]) * torch.det(AO)
+        assert torch.allclose(jac_auto.sum(), jac_trace.sum())
 
         hess_auto = self.wf.test_hess_autograd(self.x)
-        hess_trace = btrace(iAO@d2AO[:, :4, :4]) * torch.det(AO)
-        assert(torch.allclose(hess_auto.sum(), hess_trace.sum()))
+        hess_trace = btrace(iAO @ d2AO[:, :4, :4]) * torch.det(AO)
+        assert torch.allclose(hess_auto.sum(), hess_trace.sum())
 
     def test_kinetic(self):
         """Test the values kinetic energy computed via autograd and
@@ -286,8 +281,7 @@ def test_kinetic(self):
         wfv = self.wf(self.x)
         kin_auto /= wfv
 
-        kin_trace = self.wf.kinetic_energy_jacobi(
-            self.x, return_local_energy=True)
+        kin_trace = self.wf.kinetic_energy_jacobi(self.x, return_local_energy=True)
 
         delta = kin_auto / kin_trace
         print(delta)
diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index e04ef76e..64d8e722 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -1,45 +1,27 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow, SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
-
-from torch.autograd import grad, Variable
-
 import numpy as np
 import torch
 import unittest
 
-# set_torch_double_precision()
-set_torch_double_precision()
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-    return hess
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import (
+    BackFlowKernelInverse,
+)
 
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -47,33 +29,50 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrowBackFlow(mol,
-                                        kinetic='jacobi',
-                                        include_all_mo=True,
-                                        configs='single_double(2,2)',
-                                        backflow_kernel=BackFlowKernelInverse,
-                                        orbital_dependent_backflow=False)
-
-        self.wf.ao.backflow_trans.backflow_kernel.weight.data *= 0.
-
-        self.wf_ref = SlaterJastrow(mol,
-                                    kinetic='jacobi',
-                                    include_all_mo=True,
-                                    configs='single_double(2,2)')
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(
+            mol,
+            PadeJastrowKernel,
+        )
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse, orbital_dependent=False
+        )
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=backflow,
+        )
+
+        self.wf.ao.backflow_trans.backflow_kernel.weight.data *= 0.0
+
+        self.wf_ref = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=None,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
         self.wf_ref.fc.weight.data = self.random_fc_weight
 
         self.nbatch = 5
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
     def test_forward(self):
@@ -81,53 +80,45 @@ def test_forward(self):
         wf_val = self.wf(self.pos)
         wf_val_ref = self.wf_ref(self.pos)
 
-        assert(torch.allclose(wf_val, wf_val_ref))
+        assert torch.allclose(wf_val, wf_val_ref)
 
     def test_jacobian_mo(self):
         """Check that backflow give same results as normal SlaterJastrow."""
 
         dmo = self.wf.pos2mo(self.pos, derivative=1)
         dmo_ref = self.wf_ref.pos2mo(self.pos, derivative=1)
-        assert(torch.allclose(dmo.sum(0), dmo_ref))
+        assert torch.allclose(dmo.sum(0), dmo_ref)
 
     def test_hess_mo(self):
         """Check that backflow give same results as normal SlaterJastrow."""
         d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
         d2val = self.wf.ao2mo(d2ao)
 
-        d2ao_ref = self.wf_ref.ao(
-            self.pos, derivative=2, sum_hess=True)
+        d2ao_ref = self.wf_ref.ao(self.pos, derivative=2, sum_hess=True)
         d2val_ref = self.wf_ref.ao2mo(d2ao_ref)
-        assert(torch.allclose(d2val_ref, d2val.sum(0)))
-
-    def test_grad_wf(self):
-        pass
+        assert torch.allclose(d2val_ref, d2val.sum(0))
 
     def test_local_energy(self):
-
         self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
         eloc_jac = self.wf.local_energy(self.pos)
 
         self.wf_ref.kinetic_energy = self.wf_ref.kinetic_energy_jacobi
         eloc_jac_ref = self.wf_ref.local_energy(self.pos)
 
-        assert torch.allclose(
-            eloc_jac_ref.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(eloc_jac_ref.data, eloc_jac.data, rtol=1e-4, atol=1e-4)
 
     def test_kinetic_energy(self):
-
         ejac_ref = self.wf_ref.kinetic_energy_jacobi(self.pos)
         ejac = self.wf.kinetic_energy_jacobi(self.pos)
 
-        assert torch.allclose(
-            ejac_ref.data, ejac.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(ejac_ref.data, ejac.data, rtol=1e-4, atol=1e-4)
 
 
 if __name__ == "__main__":
-    t = TestCompareSlaterJastrowBackFlow()
-    t.setUp()
-    t.test_jacobian_mo()
-    t.test_hess_mo()
-    t.test_kinetic_energy()
-    t.test_local_energy()
-    # unittest.main()
+    # t = TestCompareSlaterJastrowBackFlow()
+    # t.setUp()
+    # t.test_jacobian_mo()
+    # t.test_hess_mo()
+    # t.test_kinetic_energy()
+    # t.test_local_energy()
+    unittest.main()
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index 935fe2bc..8f38ad66 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -1,45 +1,27 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow, SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
-
-from torch.autograd import grad, Variable
-
 import numpy as np
 import torch
 import unittest
 
-set_torch_double_precision()
-
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import (
+    BackFlowKernelInverse,
+)
 
-    return hess
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
 
 
 class TestCompareSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -47,34 +29,48 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrowBackFlow(mol,
-                                        kinetic='jacobi',
-                                        include_all_mo=True,
-                                        configs='single_double(2,2)',
-                                        backflow_kernel=BackFlowKernelInverse,
-                                        orbital_dependent_backflow=True)
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse, orbital_dependent=True
+        )
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=backflow,
+        )
 
         for ker in self.wf.ao.backflow_trans.backflow_kernel.orbital_dependent_kernel:
             ker.weight.data *= 0
 
-        self.wf_ref = SlaterJastrow(mol,
-                                    kinetic='jacobi',
-                                    include_all_mo=True,
-                                    configs='single_double(2,2)')
+        self.wf_ref = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=None,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
         self.wf_ref.fc.weight.data = self.random_fc_weight
 
         self.nbatch = 5
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
     def test_forward(self):
@@ -82,53 +78,45 @@ def test_forward(self):
         wf_val = self.wf(self.pos)
         wf_val_ref = self.wf_ref(self.pos)
 
-        assert(torch.allclose(wf_val, wf_val_ref))
+        assert torch.allclose(wf_val, wf_val_ref)
 
     def test_jacobian_mo(self):
         """Check that backflow give same results as normal SlaterJastrow."""
 
         dmo = self.wf.pos2mo(self.pos, derivative=1)
         dmo_ref = self.wf_ref.pos2mo(self.pos, derivative=1)
-        assert(torch.allclose(dmo.sum(0), dmo_ref))
+        assert torch.allclose(dmo.sum(0), dmo_ref)
 
     def test_hess_mo(self):
         """Check that backflow give same results as normal SlaterJastrow."""
         d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
         d2val = self.wf.ao2mo(d2ao)
 
-        d2ao_ref = self.wf_ref.ao(
-            self.pos, derivative=2, sum_hess=True)
+        d2ao_ref = self.wf_ref.ao(self.pos, derivative=2, sum_hess=True)
         d2val_ref = self.wf_ref.ao2mo(d2ao_ref)
-        assert(torch.allclose(d2val_ref, d2val.sum(0)))
-
-    def test_grad_wf(self):
-        pass
+        assert torch.allclose(d2val_ref, d2val.sum(0))
 
     def test_local_energy(self):
-
         self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
         eloc_jac = self.wf.local_energy(self.pos)
 
         self.wf_ref.kinetic_energy = self.wf_ref.kinetic_energy_jacobi
         eloc_jac_ref = self.wf_ref.local_energy(self.pos)
 
-        assert torch.allclose(
-            eloc_jac_ref.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(eloc_jac_ref.data, eloc_jac.data, rtol=1e-4, atol=1e-4)
 
     def test_kinetic_energy(self):
-
         ejac_ref = self.wf_ref.kinetic_energy_jacobi(self.pos)
         ejac = self.wf.kinetic_energy_jacobi(self.pos)
 
-        assert torch.allclose(
-            ejac_ref.data, ejac.data, rtol=1E-4, atol=1E-4)
+        assert torch.allclose(ejac_ref.data, ejac.data, rtol=1e-4, atol=1e-4)
 
 
 if __name__ == "__main__":
-    t = TestCompareSlaterJastrowOrbitalDependentBackFlow()
-    t.setUp()
-    t.test_jacobian_mo()
-    t.test_hess_mo()
-    t.test_kinetic_energy()
-    t.test_local_energy()
-    # unittest.main()
+    # t = TestCompareSlaterJastrowOrbitalDependentBackFlow()
+    # t.setUp()
+    # t.test_jacobian_mo()
+    # t.test_hess_mo()
+    # t.test_kinetic_energy()
+    # t.test_local_energy()
+    unittest.main()
diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 14f3c322..4278eb6c 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -1,43 +1,18 @@
+import unittest
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
-from qmctorch.utils import set_torch_double_precision
-
-from torch.autograd import grad, Variable
-
 import numpy as np
 import torch
-import unittest
-
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
-
-
-class TestSlaterOrbitalDependentJastrow(unittest.TestCase):
+from .base_test_cases import BaseTestCases
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+from qmctorch.utils import set_torch_double_precision
 
+class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -45,181 +20,42 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel, orbital_dependent_kernel=True)
 
-        self.wf = SlaterOrbitalDependentJastrow(
+        self.wf = SlaterJastrow(
             mol,
-            kinetic='auto',
-            jastrow_kernel=FullyConnectedJastrowKernel,
-            configs='single_double(2,4)',
-            include_all_mo=True)
+            kinetic="auto",
+            include_all_mo=False,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=None,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
-
-        self.nbatch = 3
-        self.pos = torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
-
+        self.nbatch = 11
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        """Value of the wave function."""
-        wfvals = self.wf(self.pos)
-        # ref = torch.as_tensor([[-1.0935e-02], [6.4874e-02], [1.7879e-04],
-        #                        [1.5797e-02], [7.4684e-02], [-4.4445e-02],
-        #                        [-4.8149e-04], [-3.0355e-03], [-2.0027e-02],
-        #                        [5.1957e-05]])
-        # assert torch.allclose(wfvals.data, ref, rtol=1E-4, atol=1E-4)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1.*wfvals_xup))
-
-    def test_jacobian_mo(self):
-        """Jacobian of the uncorrelated MOs."""
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-        dmo_grad = grad(
-            mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
+    def test_gradients_wf(self):
+        pass
 
-        assert(torch.allclose(dmo.sum(-1),
-                              dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_grad_mo(self):
-        """Gradients of the uncorrelated MOs."""
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1, sum_grad=False)
-        dmo_grad = grad(
-            mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
-
-        assert(torch.allclose(dmo.sum(-2),
-                              dmo_grad.view(self.nbatch, self.wf.nelec, 3)))
-
-    def test_hess_mo(self):
-        """Hessian of the uncorrelated MOs."""
-        mo = self.wf.pos2mo(self.pos)
-        d2mo = self.wf.pos2mo(self.pos, derivative=2)
-        d2mo_grad = hess(mo, self.pos)
-
-        assert(torch.allclose(d2mo.sum(-1),
-                              d2mo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_jacobian_jast(self):
-        """Jacobian of the jastrow values."""
-        jast = self.wf.ordered_jastrow(self.pos)
-        djast = self.wf.ordered_jastrow(self.pos, derivative=1)
-        djast_grad = grad(jast, self.pos,
-                          grad_outputs=torch.ones_like(jast))[0]
-
-        assert(torch.allclose(djast_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1),
-                              djast.sum(-1)))
-
-    def test_grad_jast(self):
-        """Gradients of the jastrow values."""
-        jast = self.wf.ordered_jastrow(self.pos)
-        djast = self.wf.ordered_jastrow(
-            self.pos, derivative=1, sum_grad=False)
-        djast_grad = grad(jast, self.pos,
-                          grad_outputs=torch.ones_like(jast))[0]
-
-        assert(torch.allclose(djast_grad.view(self.nbatch, self.wf.nelec, 3),
-                              djast.sum(-2)))
-
-    def test_hess_jast(self):
-        """Hessian of the jastrows."""
-        jast = self.wf.ordered_jastrow(self.pos)
-        d2jast = self.wf.ordered_jastrow(self.pos, derivative=2)
-
-        d2jast_grad = hess(jast, self.pos)
-
-        assert(torch.allclose(d2jast.sum(-1),
-                              d2jast_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_grad_cmo(self):
-        """Gradients of the correlated MOs."""
-        cmo = self.wf.pos2cmo(self.pos)
-        dcmo = self.wf.get_gradient_operator(self.pos)
-
-        dcmo = dcmo.permute(1, 2, 3, 0)
-        shape = (self.nbatch, self.wf.nelec,
-                 self.wf.nmo_opt, self.wf.nelec, 3)
-        dcmo = dcmo.reshape(*shape)
-        dcmo = dcmo.sum(2).sum(1)
-
-        dcmo_grad = grad(cmo, self.pos,
-                         grad_outputs=torch.ones_like(cmo))[0]
-        dcmo_grad = dcmo_grad.reshape(self.nbatch, self.wf.nelec, 3)
-
-        assert(torch.allclose(dcmo, dcmo_grad))
-
-    def test_hess_cmo(self):
-        """Hessian of the correlated MOs."""
-        val = self.wf.pos2cmo(self.pos)
-        d2val_grad = hess(val, self.pos)
-
-        d2val = self.wf.get_hessian_operator(self.pos)
-        d2val = d2val.permute(1, 2, 0, 3).sum(1)
-
-        assert(torch.allclose(d2val.sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_jacobian_wf(self):
-        """Jacobian of det(CMO).
-            \nabla det(CMOup) / det(CMOup) +  \nabla det(CMOup) / det(CMOup) """
-        grad_jacobi = self.wf.gradients_jacobi(self.pos)
-        grad_auto = self.wf.gradients_autograd(self.pos)
-        assert(torch.allclose(grad_jacobi, grad_auto.sum(-1)))
-
-    def test_grad_wf(self):
-        """Compute the gradients of the wf  wrt to xyz coord of each elec."""
-        grad_jacobi = self.wf.gradients_jacobi(
-            self.pos, sum_grad=False).squeeze()
-        grad_auto = self.wf.gradients_autograd(self.pos)
-        assert torch.allclose(grad_jacobi, grad_auto)
+    def test_gradients_pdf(self):
+        pass
 
     def test_kinetic_energy(self):
-        """Kinetic energty."""
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
+        pass
 
     def test_local_energy(self):
-        """local energy."""
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
+        pass
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 6ad292ef..edc6970f 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -1,46 +1,31 @@
-from qmctorch.scf import Molecule
-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
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import BoysHandyJastrowKernel, FullyConnectedJastrowKernel
-from torch.autograd import grad, gradcheck, Variable
-
+import unittest
 import numpy as np
 import torch
-import unittest
-
-set_torch_double_precision()
-
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from .base_test_cases import BaseTestCases
 
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.utils import set_torch_double_precision
+from qmctorch.wavefunction.jastrows.jastrow_factor_combined_terms import (
+    JastrowFactorCombinedTerms,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecNuc,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecElec,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import (
+    BoysHandyJastrowKernel,
+)
 
-    return hess
 
+set_torch_double_precision()
 
-class TestSlaterCombinedJastrow(unittest.TestCase):
 
+class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -48,140 +33,37 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.14',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterManyBodyJastrow(mol,
-                                        kinetic='auto',
-                                        include_all_mo=False,
-                                        configs='single_double(2,2)',
-                                        jastrow_kernel={
-                                            'ee': PadeJastrowKernelElecElec,
-                                            'en': PadeJastrowKernelElecNuc,
-                                            'een': BoysHandyJastrowKernel},
-                                        jastrow_kernel_kwargs={
-                                            'ee': {'w': 1.},
-                                            'en': {'w': 1.},
-                                            'een': {}})
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        jastrow = JastrowFactorCombinedTerms(
+            mol,
+            jastrow_kernel={
+                "ee": PadeJastrowKernelElecElec,
+                "en": PadeJastrowKernelElecNuc,
+                "een": BoysHandyJastrowKernel,
+            },
+            jastrow_kernel_kwargs={"ee": {"w": 1.0}, "en": {"w": 1.0}, "een": {}},
+        )
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=False,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
         self.nbatch = 11
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        _ = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1 * wfvals_xup))
-
-        # test spin down
-        pos_xdn = self.pos.clone()
-        perm_dn = list(range(self.wf.nelec))
-        perm_dn[self.wf.mol.nup-1] = self.wf.mol.nup
-        perm_dn[self.wf.mol.nup] = self.wf.mol.nup-1
-        pos_xdn = pos_xdn.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xdn = pos_xdn[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xdn = self.wf(pos_xdn)
-        assert(torch.allclose(wfvals_ref, -1.*wfvals_xdn))
-
-    def test_grad_mo(self):
-        """Gradients of the MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo,
-            self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-
-        gradcheck(self.wf.pos2mo, self.pos)
-
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-        assert(torch.allclose(dmo.sum(-1),
-                              dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2val = self.wf.pos2mo(self.pos, derivative=2)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        assert(torch.allclose(d2val.sum(-1).sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1).sum(-1)))
-
-        assert(torch.allclose(d2val.sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test_gradients_wf(self):
-
-        grads = self.wf.gradients_jacobi(
-            self.pos, sum_grad=False).squeeze()
-        grad_auto = self.wf.gradients_autograd(self.pos)
-
-        assert torch.allclose(grads.sum(), grad_auto.sum())
-
-        grads = grads.reshape(self.nbatch, self.wf.nelec, 3)
-        grad_auto = grad_auto.reshape(self.nbatch, self.wf.nelec, 3)
-        assert(torch.allclose(grads, grad_auto))
-
-    def test_gradients_pdf(self):
-
-        grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
-        grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
-
-        assert torch.allclose(grads_pdf.sum(), grads_auto.sum())
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index c5c99b31..018fff97 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -1,48 +1,38 @@
-from qmctorch.scf import Molecule
-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
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import BoysHandyJastrowKernel, FullyConnectedJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
-
-from torch.autograd import grad, gradcheck, Variable
-
 import numpy as np
 import torch
 import unittest
 
-set_torch_double_precision()
-
+from .base_test_cases import BaseTestCases
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
-
-    return hess
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+
+from qmctorch.wavefunction.jastrows.jastrow_factor_combined_terms import (
+    JastrowFactorCombinedTerms,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecNuc,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import (
+    PadeJastrowKernel as PadeJastrowKernelElecElec,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import (
+    BoysHandyJastrowKernel,
+)
+
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import (
+    BackFlowKernelInverse,
+)
 
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
 
-class TestSlaterCombinedJastrowBackflow(unittest.TestCase):
 
+class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -50,144 +40,49 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.14',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterManyBodyJastrowBackflow(mol,
-                                                kinetic='auto',
-                                                include_all_mo=False,
-                                                configs='single_double(2,2)',
-                                                jastrow_kernel={
-                                                    'ee': PadeJastrowKernelElecElec,
-                                                    'en': PadeJastrowKernelElecNuc,
-                                                    'een': BoysHandyJastrowKernel},
-                                                jastrow_kernel_kwargs={
-                                                    'ee': {'w': 1.},
-                                                    'en': {'w': 1.},
-                                                    'een': {}})
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorCombinedTerms(
+            mol,
+            jastrow_kernel={
+                "ee": PadeJastrowKernelElecElec,
+                "en": PadeJastrowKernelElecNuc,
+                "een": BoysHandyJastrowKernel,
+            },
+            jastrow_kernel_kwargs={"ee": {"w": 1.0}, "en": {"w": 1.0}, "een": {}},
+        )
+
+        # define backflow trans
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=backflow,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
-        self.nbatch = 11
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
-        self.pos.requires_grad = True
-
-    def test_forward(self):
-        wfvals = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1.*wfvals_xup))
-
-    def test_jacobian_mo(self):
-        """Jacobian of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
 
-        dmo_grad = grad(
-            mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        psum_mo = dmo.sum(-1).sum(-1)
-        psum_mo_grad = dmo_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        psum_mo_grad = psum_mo_grad.T
-        assert(torch.allclose(psum_mo, psum_mo_grad))
-
-    def test_grad_mo(self):
-        """Gradients of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-        dmo = self.wf.ao2mo(dao)
-
-        dmo_grad = grad(
-            mo, self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        dmo = dmo.sum(-1).sum(-1)
-        dmo_grad = dmo_grad.T
-
-        assert(torch.allclose(dmo, dmo_grad))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
-        d2val = self.wf.ao2mo(d2ao)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        d2val = d2val.reshape(4, 3, 11, 4, 3).sum(1).sum(-1).sum(-1)
-        d2val_grad = d2val_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        d2val_grad = d2val_grad.T
-        assert(torch.allclose(d2val, d2val_grad))
-
-    def test_grad_wf(self):
-        pass
-
-        # grad_auto = self.wf.gradients_autograd(self.pos)
-        # grad_jac = self.wf.gradients_jacobi(self.pos)
-
-        # assert torch.allclose(
-        #     grad_auto.data, grad_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        print(ejac)
-        print(eauto)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
+        self.nbatch = 5
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
+        self.pos.requires_grad = True
 
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestSlaterCombinedJastrowBackflow()
-    t.setUp()
-    t.test_hess_mo()
+    unittest.main()
+    # t = TestSlaterJastrowBackFlow()
+    # t.setUp()
     # t.test_antisymmetry()
+    # t.test_hess_mo()
+    # t.test_grad_mo()
     # t.test_kinetic_energy()
diff --git a/tests/wavefunction/test_slatercombinedjastrow_internal.py b/tests/wavefunction/test_slatercombinedjastrow_internal.py
new file mode 100644
index 00000000..661a25b3
--- /dev/null
+++ b/tests/wavefunction/test_slatercombinedjastrow_internal.py
@@ -0,0 +1,63 @@
+import unittest
+import numpy as np
+import torch
+
+from .base_test_cases import BaseTestCases
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.utils import set_torch_double_precision
+from qmctorch.wavefunction.jastrows.elec_elec import (
+    JastrowFactor as JastrowFactorElecElec,
+    FullyConnectedJastrowKernel as FCEE,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei import (
+    JastrowFactor as JastrowFactorElecNuclei,
+    FullyConnectedJastrowKernel as FCEN,
+)
+
+
+torch.set_default_tensor_type(torch.DoubleTensor)
+
+
+class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
+    def setUp(self):
+        torch.manual_seed(101)
+        np.random.seed(101)
+
+        set_torch_double_precision()
+
+        # molecule
+        mol = Molecule(
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # jastrow
+        jastrow_ee = JastrowFactorElecElec(mol, FCEE)
+        jastrow_en = JastrowFactorElecNuclei(mol, FCEN)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=False,
+            configs="single_double(2,2)",
+            jastrow=[jastrow_ee, jastrow_en],
+        )
+
+        self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
+        self.wf.fc.weight.data = self.random_fc_weight
+        self.nbatch = 11
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
+        self.pos.requires_grad = True
+
+
+if __name__ == "__main__":
+    unittest.main()
+    # t = TestSlaterCombinedJastrow()
+    # t.setUp()
+    # t.test_antisymmetry()
+    # t.test_kinetic_energy()
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index fe5bf8c4..4e0288ff 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -1,44 +1,27 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-
-from torch.autograd import grad, gradcheck, Variable
-
+import unittest
 import numpy as np
 import torch
-import unittest
-
-set_torch_double_precision()
 
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
+from .base_test_cases import BaseTestCases
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.utils import set_torch_double_precision
 
-    return hess
 
+set_torch_double_precision()
 
-class TestSlaterJastrow(unittest.TestCase):
 
+class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -46,132 +29,31 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.14',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)')
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=False,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=None,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
         self.nbatch = 11
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        _ = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xup))
-
-        # test spin down
-        pos_xdn = self.pos.clone()
-        perm_dn = list(range(self.wf.nelec))
-        perm_dn[self.wf.mol.nup-1] = self.wf.mol.nup
-        perm_dn[self.wf.mol.nup] = self.wf.mol.nup-1
-        pos_xdn = pos_xdn.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xdn = pos_xdn[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xdn = self.wf(pos_xdn)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xdn))
-
-    def test_grad_mo(self):
-        """Gradients of the MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo,
-            self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-
-        gradcheck(self.wf.pos2mo, self.pos)
-
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-        assert(torch.allclose(dmo.sum(-1),
-                              dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2val = self.wf.pos2mo(self.pos, derivative=2)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        assert(torch.allclose(d2val.sum(-1).sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1).sum(-1)))
-
-        assert(torch.allclose(d2val.sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test_gradients_wf(self):
-
-        grads = self.wf.gradients_jacobi(
-            self.pos, sum_grad=False).squeeze()
-        grad_auto = self.wf.gradients_autograd(self.pos)
-
-        assert torch.allclose(grads.sum(), grad_auto.sum())
-
-        grads = grads.reshape(self.nbatch, self.wf.nelec, 3)
-        grad_auto = grad_auto.reshape(self.nbatch, self.wf.nelec, 3)
-        assert(torch.allclose(grads, grad_auto))
-
-    def test_gradients_pdf(self):
-
-        grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
-        grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
-
-        assert torch.allclose(grads_pdf.sum(), grads_auto.sum())
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 3c0faac3..8afb6c50 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -1,48 +1,24 @@
-
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
-from qmctorch.utils import set_torch_double_precision
-
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
-
-from torch.autograd import grad, Variable
-
 import numpy as np
 import torch
 import unittest
 
-set_torch_double_precision()
-
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from .base_test_cases import BaseTestCases
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-    return hess
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
 
-class TestSlaterJastrowBackFlow(unittest.TestCase):
 
+class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -50,135 +26,35 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrowBackFlow(mol,
-                                        kinetic='jacobi',
-                                        jastrow_kernel=PadeJastrowKernel,
-                                        include_all_mo=True,
-                                        configs='single_double(2,2)',
-                                        backflow_kernel=BackFlowKernelInverse,
-                                        orbital_dependent_backflow=False)
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=backflow,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
 
         self.nbatch = 5
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        wfvals = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1.*wfvals_xup))
-
-    def test_jacobian_mo(self):
-        """Jacobian of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        psum_mo = dmo.sum(-1).sum(-1)
-        psum_mo_grad = dmo_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        psum_mo_grad = psum_mo_grad.T
-        assert(torch.allclose(psum_mo, psum_mo_grad))
-
-    def test_grad_mo(self):
-        """Gradients of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-        dmo = self.wf.ao2mo(dao)
-
-        dmo_grad = grad(
-            mo, self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        dmo = dmo.sum(-1).sum(-1)
-        dmo_grad = dmo_grad.T
-
-        assert(torch.allclose(dmo, dmo_grad))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
-        d2val = self.wf.ao2mo(d2ao)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        d2val = d2val.reshape(4, 3, 5, 4, 6).sum(1).sum(-1).sum(-1)
-        d2val_grad = d2val_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        d2val_grad = d2val_grad.T
-        assert(torch.allclose(d2val, d2val_grad))
-
-    def test_grad_wf(self):
-        pass
-
-        # grad_auto = self.wf.gradients_autograd(self.pos)
-        # grad_jac = self.wf.gradients_jacobi(self.pos)
-
-        # assert torch.allclose(
-        #     grad_auto.data, grad_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        print(ejac)
-        print(eauto)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index 05b083b4..a6fab0bf 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -1,44 +1,24 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-
-from torch.autograd import grad, gradcheck, Variable
-
+import unittest
 import numpy as np
 import torch
-import unittest
 
-set_torch_double_precision()
+from .base_test_cases import BaseTestCases
 
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
-
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+from qmctorch.utils import set_torch_double_precision
 
-    return hess
 
+set_torch_double_precision()
 
-class TestOrbitalWF(unittest.TestCase):
 
+class TestSlaterJastrowCAS(BaseTestCases.WaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -46,168 +26,31 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 1.',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=True,
-                                configs='cas(2,2)')
+            atom="Li 0 0 0; H 0 0 1.",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=True,
+            configs="cas(2,2)",
+            jastrow=jastrow,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
 
         self.nbatch = 10
-        self.pos = torch.Tensor(
-            np.random.rand(self.nbatch, mol.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, mol.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-
-        wfvals = self.wf(self.pos)
-
-        ref = torch.Tensor([[0.0522],
-                            [0.0826],
-                            [0.0774],
-                            [0.1321],
-                            [0.0459],
-                            [0.0421],
-                            [0.0551],
-                            [0.0764],
-                            [0.1164],
-                            [0.2506]])
-        # assert torch.allclose(wfvals.data, ref, rtol=1E-4, atol=1E-4)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xup))
-
-        # test spin down
-        pos_xdn = self.pos.clone()
-        perm_dn = list(range(self.wf.nelec))
-        perm_dn[self.wf.mol.nup-1] = self.wf.mol.nup
-        perm_dn[self.wf.mol.nup] = self.wf.mol.nup-1
-        pos_xdn = pos_xdn.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xdn = pos_xdn[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xdn = self.wf(pos_xdn)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xdn))
-
-    def test_grad_mo(self):
-        """Gradients of the MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo,
-            self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-
-        gradcheck(self.wf.pos2mo, self.pos)
-
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-        assert(torch.allclose(dmo.sum(-1),
-                              dmo_grad.view(10, self.wf.nelec, 3).sum(-1)))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2val = self.wf.pos2mo(self.pos, derivative=2)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        assert(torch.allclose(d2val.sum(-1).sum(-1),
-                              d2val_grad.view(10, self.wf.nelec, 3).sum(-1).sum(-1)))
-
-        assert(torch.allclose(d2val.sum(-1),
-                              d2val_grad.view(10, self.wf.nelec, 3).sum(-1)))
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        ref = torch.Tensor([[-1.6567],
-                            [-0.8790],
-                            [-2.8136],
-                            [-0.3644],
-                            [-0.4477],
-                            [-0.2709],
-                            [-0.6964],
-                            [-0.3993],
-                            [-0.4777],
-                            [-0.0579]])
-
-        # assert torch.allclose(
-        #     eloc_auto.data, ref, rtol=1E-4, atol=1E-4)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        ref = torch.Tensor([[0.6099],
-                            [0.6438],
-                            [0.6313],
-                            [2.0512],
-                            [0.0838],
-                            [0.2699],
-                            [0.5190],
-                            [0.3381],
-                            [1.8489],
-                            [5.2226]])
-
-        # assert torch.allclose(
-        #     ejac.data, ref, rtol=1E-4, atol=1E-4)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test_gradients_wf(self):
-
-        grads = self.wf.gradients_jacobi(self.pos)
-        grad_auto = self.wf.gradients_autograd(self.pos)
-        assert torch.allclose(grads, grad_auto)
-
-    def test_gradients_pdf(self):
-
-        grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
-        grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
-
-        assert torch.allclose(grads_pdf, grads_auto)
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index cff4a70b..2b63085d 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -1,19 +1,24 @@
+import unittest
+import numpy as np
+import torch
+
+
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-import numpy as np
-import torch
-import unittest
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+
 
 set_torch_double_precision()
 
 
 class TestSlaterJastrowElectronCusp(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -21,35 +26,39 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='He 0.5 0 0; He -0.5 0 0',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrow(mol,
-                                jastrow_kernel=FullyConnectedJastrowKernel,
-                                kinetic='jacobi',
-                                include_all_mo=True,
-                                configs='ground_state')
+            atom="He 0.5 0 0; He -0.5 0 0",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+
+        self.wf = SlaterJastrow(
+            mol,
+            jastrow=jastrow,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="ground_state",
+        )
 
         self.nbatch = 100
 
     def test_ee_cusp(self):
-
         import matplotlib.pyplot as plt
-        pos_x = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec, 3))
+
+        pos_x = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec, 3))
         x = torch.linspace(0, 2, self.nbatch)
-        pos_x[:, 0, :] = torch.as_tensor([0., 0., 0.]) + 1E-6
-        pos_x[:, 1, 0] = 0.
-        pos_x[:, 1, 1] = 0.
+        pos_x[:, 0, :] = torch.as_tensor([0.0, 0.0, 0.0]) + 1e-6
+        pos_x[:, 1, 0] = 0.0
+        pos_x[:, 1, 1] = 0.0
         pos_x[:, 1, 2] = x
 
-        pos_x[:, 2, :] = 0.5*torch.as_tensor([1., 1., 1.])
-        pos_x[:, 3, :] = -0.5*torch.as_tensor([1., 1., 1.])
+        pos_x[:, 2, :] = 0.5 * torch.as_tensor([1.0, 1.0, 1.0])
+        pos_x[:, 3, :] = -0.5 * torch.as_tensor([1.0, 1.0, 1.0])
 
-        pos_x = pos_x.reshape(self.nbatch, self.wf.nelec*3)
+        pos_x = pos_x.reshape(self.nbatch, self.wf.nelec * 3)
         pos_x.requires_grad = True
 
         x = x.detach().numpy()
@@ -57,10 +66,10 @@ def test_ee_cusp(self):
         plt.plot(x, j)
         plt.show()
 
-        dx = x[1]-x[0]
-        dj = (j[1:]-j[0:-1])/dx
+        dx = x[1] - x[0]
+        dj = (j[1:] - j[0:-1]) / dx
 
-        plt.plot(x[:-1], dj/j[:-1])
+        plt.plot(x[:-1], dj / j[:-1])
         plt.show()
 
         epot = self.wf.electronic_potential(pos_x).detach().numpy()
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index e453521e..50116163 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -1,46 +1,27 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
-
-from torch.autograd import grad, gradcheck, Variable
-
+import unittest
 import numpy as np
 import torch
-import unittest
-
-
-set_torch_double_precision()
 
+from .base_test_cases import BaseTestCases
 
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.utils import set_torch_double_precision
 
-    return hess
 
+set_torch_double_precision()
 
-class TestGenericJastrowWF(unittest.TestCase):
 
+class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -48,128 +29,31 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 1.',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                configs='ground_state',
-                                jastrow_kernel=FullyConnectedJastrowKernel)
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=False,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=None,
+        )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight
-
-        self.nbatch = 10
-        self.pos = 1E-2 * torch.as_tensor(np.random.rand(
-            self.nbatch, self.wf.nelec*3))
+        self.nbatch = 11
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        wfvals = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xup))
-
-    def test_grad_mo(self):
-        """Gradients of the MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo,
-            self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-
-        gradcheck(self.wf.pos2mo, self.pos)
-
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-        assert(torch.allclose(dmo.sum(-1),
-                              dmo_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2val = self.wf.pos2mo(self.pos, derivative=2)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        assert(torch.allclose(d2val.sum(-1).sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1).sum(-1)))
-
-        assert(torch.allclose(d2val.sum(-1),
-                              d2val_grad.view(self.nbatch, self.wf.nelec, 3).sum(-1)))
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
-    def test_gradients_wf(self):
-
-        grads = self.wf.gradients_jacobi(self.pos)
-        grad_auto = self.wf.gradients_autograd(self.pos)
-
-        assert torch.allclose(grads, grad_auto)
-
-        grads = grads.reshape(10, self.wf.nelec, 3)
-        grad_auto = grad_auto.reshape(10, self.wf.nelec, 3)
-        assert(torch.allclose(grads, grad_auto))
-
-    def test_gradients_pdf(self):
-
-        grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
-        grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
-
-        assert torch.allclose(grads_pdf, grads_auto)
-
 
 if __name__ == "__main__":
     unittest.main()
-    # t = TestGenericJastrowWF()
-    # t.setUp()
-    # t.test_antisymmetry()
-    # # # t.test_forward()
-    # # # # t.test_local_energy()
-    # # # # t.test_kinetic_energy()
-    # t.test_gradients_wf()
-    # # t.test_gradients_pdf()
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 6c0fe76c..b391e6b7 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -1,49 +1,31 @@
-
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow
-
-from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
-
-from qmctorch.utils import set_torch_double_precision
-
-from torch.autograd import grad, Variable
-
 import numpy as np
 import torch
 import unittest
 
-set_torch_double_precision()
-
-
-def hess(out, pos):
-    # compute the jacobian
-    z = Variable(torch.ones(out.shape))
-    jacob = grad(out, pos,
-                 grad_outputs=z,
-                 only_inputs=True,
-                 create_graph=True)[0]
-
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
-
-    for idim in range(jacob.shape[1]):
+from .base_test_cases import BaseTestCases
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
-
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
-    return hess
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
+    BackFlowTransformation,
+)
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import (
+    BackFlowKernelInverse,
+)
+from qmctorch.utils import set_torch_double_precision
+set_torch_double_precision()
 
-class TestSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
 
+class TestSlaterJastrowOrbitalDependentBackFlow(
+    BaseTestCases.BackFlowWaveFunctionBaseTest
+):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -51,20 +33,29 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterJastrowBackFlow(mol,
-                                        kinetic='jacobi',
-                                        jastrow_kernel=PadeJastrowKernel,
-                                        include_all_mo=True,
-                                        configs='single_double(2,2)',
-                                        backflow_kernel=BackFlowKernelInverse,
-                                        orbital_dependent_backflow=True
-                                        )
+            atom="Li 0 0 0; H 0 0 3.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse, orbital_dependent=True
+        )
+
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="jacobi",
+            include_all_mo=True,
+            configs="single_double(2,2)",
+            jastrow=jastrow,
+            backflow=backflow,
+        )
 
         # change the weights
         for ker in self.wf.ao.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -74,117 +65,9 @@ def setUp(self):
         self.wf.fc.weight.data = self.random_fc_weight
 
         self.nbatch = 5
-        self.pos = torch.Tensor(np.random.rand(
-            self.nbatch,  self.wf.nelec*3))
+        self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
-    def test_forward(self):
-        wfvals = self.wf(self.pos)
-
-    def test_antisymmetry(self):
-        """Test that the wf values are antisymmetric
-        wrt exchange of 2 electrons of same spin."""
-        wfvals_ref = self.wf(self.pos)
-
-        if self.wf.nelec < 4:
-            print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
-            return
-
-        # test spin up
-        pos_xup = self.pos.clone()
-        perm_up = list(range(self.wf.nelec))
-        perm_up[0] = 1
-        perm_up[1] = 0
-        pos_xup = pos_xup.reshape(self.nbatch, self.wf.nelec, 3)
-        pos_xup = pos_xup[:, perm_up, :].reshape(
-            self.nbatch, self.wf.nelec*3)
-
-        wfvals_xup = self.wf(pos_xup)
-        assert(torch.allclose(wfvals_ref, -1*wfvals_xup))
-
-    def test_jacobian_mo(self):
-        """Jacobian of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-        dmo = self.wf.pos2mo(self.pos, derivative=1)
-
-        dmo_grad = grad(
-            mo, self.pos, grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        psum_mo = dmo.sum(-1).sum(-1)
-        psum_mo_grad = dmo_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        psum_mo_grad = psum_mo_grad.T
-        assert(torch.allclose(psum_mo, psum_mo_grad))
-
-    def test_grad_mo(self):
-        """Gradients of the BF MOs."""
-
-        mo = self.wf.pos2mo(self.pos)
-
-        dao = self.wf.ao(self.pos, derivative=1, sum_grad=False)
-        dmo = self.wf.ao2mo(dao)
-
-        dmo_grad = grad(
-            mo, self.pos,
-            grad_outputs=torch.ones_like(mo))[0]
-        assert(torch.allclose(dmo.sum(), dmo_grad.sum()))
-
-        dmo = dmo.sum(-1).sum(-1)
-        dmo_grad = dmo_grad.T
-
-        assert(torch.allclose(dmo, dmo_grad))
-
-    def test_hess_mo(self):
-        """Hessian of the MOs."""
-        val = self.wf.pos2mo(self.pos)
-
-        d2val_grad = hess(val, self.pos)
-        d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
-        d2val = self.wf.ao2mo(d2ao)
-
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
-
-        d2val = d2val.reshape(4, 3, 5, 4, 6).sum(1).sum(-1).sum(-1)
-        d2val_grad = d2val_grad.view(
-            self.nbatch, self.wf.nelec, 3).sum(-1)
-        d2val_grad = d2val_grad.T
-        assert(torch.allclose(d2val, d2val_grad))
-
-    def test_grad_wf(self):
-        pass
-
-        # grad_auto = self.wf.gradients_autograd(self.pos)
-        # grad_jac = self.wf.gradients_jacobi(self.pos)
-
-        # assert torch.allclose(
-        #     grad_auto.data, grad_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_local_energy(self):
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_autograd
-        eloc_auto = self.wf.local_energy(self.pos)
-
-        self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
-        eloc_jac = self.wf.local_energy(self.pos)
-
-        assert torch.allclose(
-            eloc_auto.data, eloc_jac.data, rtol=1E-4, atol=1E-4)
-
-    def test_kinetic_energy(self):
-
-        eauto = self.wf.kinetic_energy_autograd(self.pos)
-        ejac = self.wf.kinetic_energy_jacobi(self.pos)
-
-        print(ejac)
-        print(eauto)
-
-        assert torch.allclose(
-            eauto.data, ejac.data, rtol=1E-4, atol=1E-4)
-
 
 if __name__ == "__main__":
     # t = TestSlaterJastrowOrbitalDependentBackFlow()
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index eeae6913..e50a2ae4 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -9,7 +9,10 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverMPI
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
+
 from qmctorch.utils import set_torch_double_precision
 
 
@@ -33,11 +36,17 @@ def setUp(self):
             unit='bohr',
             calculator='pyscf',
             basis='sto-3g',
-            rank=hvd.local_rank())
+            rank=hvd.local_rank(),
+            mpi_size=hvd.local_size())
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
 
         # wave function
         self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
                                 configs='cas(2,2)',
+                                jastrow=jastrow,
                                 cuda=False)
 
         # sampler