From 64b3a61ea6cd42d418a67a76f0b36bbb5748a440 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 16 Jun 2021 18:31:46 +0200
Subject: [PATCH 001/286] change batching stragegy

---
 qmctorch/solver/solver_slater_jastrow.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index a1a99ccc..8aab7795 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -321,6 +321,8 @@ def run_epochs(self, nepoch):
 
             cumulative_loss = 0
 
+            self.opt.zero_grad()
+
             # loop over the batches
             for ibatch, data in enumerate(self.dataloader):
 
@@ -336,13 +338,13 @@ def run_epochs(self, nepoch):
                     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)
 
+            # optimize the parameters
+            self.optimization_step(lpos)
+
             # save the model if necessary
             if n == 0 or cumulative_loss < min_loss:
                 min_loss = cumulative_loss
@@ -385,7 +387,7 @@ def evaluate_grad_auto(self, lpos):
             loss += self.ortho_loss(self.wf.mo.weight)
 
         # compute local gradients
-        self.opt.zero_grad()
+        # self.opt.zero_grad()
         loss.backward()
 
         return loss, eloc
@@ -430,7 +432,7 @@ def evaluate_grad_manual(self, lpos):
             weight *= norm
 
             # compute the gradients
-            self.opt.zero_grad()
+            # self.opt.zero_grad()
             psi.backward(weight)
 
             return torch.mean(eloc), eloc

From 720791eda180b4148adfb29fb126e47b69132085 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 17 Jun 2021 13:59:22 +0200
Subject: [PATCH 002/286] introduced logspace sampling

---
 example/single_point/h2.py                    | 47 +++++++++++++++++++
 example/single_point/h2o_sampling.py          |  1 +
 .../plams_workdir/HH_dzp/HH_dzp.err           |  1 +
 .../plams_workdir/HH_dzp/HH_dzp.in            | 22 +++++++++
 .../plams_workdir/HH_dzp/HH_dzp.out           |  0
 .../plams_workdir/HH_dzp/HH_dzp.run           |  4 ++
 example/single_point/plams_workdir/logfile    | 14 ++++++
 qmctorch/sampler/metropolis.py                | 47 +++++++++++++++----
 qmctorch/solver/solver_base.py                |  5 +-
 tests/sampler/test_metropolis.py              | 18 +++++++
 10 files changed, 147 insertions(+), 12 deletions(-)
 create mode 100644 example/single_point/h2.py
 create mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.err
 create mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.in
 create mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.out
 create mode 100755 example/single_point/plams_workdir/HH_dzp/HH_dzp.run
 create mode 100644 example/single_point/plams_workdir/logfile

diff --git a/example/single_point/h2.py b/example/single_point/h2.py
new file mode 100644
index 00000000..10762f3a
--- /dev/null
+++ b/example/single_point/h2.py
@@ -0,0 +1,47 @@
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.utils import plot_walkers_traj
+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')
+
+
+# define the wave function
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='ground_state').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 = SolverSlaterJastrow(wf=wf, sampler=sampler)
+
+# # single point
+# obs = solver.single_point(logspace=True)
+
+# # 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/example/single_point/h2o_sampling.py b/example/single_point/h2o_sampling.py
index 46a1cdeb..a605cce8 100644
--- a/example/single_point/h2o_sampling.py
+++ b/example/single_point/h2o_sampling.py
@@ -4,6 +4,7 @@
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils import plot_walkers_traj
 
+
 # define the molecule
 mol = Molecule(atom='water.xyz', unit='angs',
                calculator='pyscf', basis='sto-3g', name='water')
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.err b/example/single_point/plams_workdir/HH_dzp/HH_dzp.err
new file mode 100644
index 00000000..7da1a13a
--- /dev/null
+++ b/example/single_point/plams_workdir/HH_dzp/HH_dzp.err
@@ -0,0 +1 @@
+./HH_dzp.run: 3: ./HH_dzp.run: /adf: not found
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.in b/example/single_point/plams_workdir/HH_dzp/HH_dzp.in
new file mode 100644
index 00000000..d6829107
--- /dev/null
+++ b/example/single_point/plams_workdir/HH_dzp/HH_dzp.in
@@ -0,0 +1,22 @@
+units
+  length Bohr
+end
+
+XC
+  HartreeFock
+end
+
+atoms
+      1         H      0.000000       0.000000      -0.690000 
+      2         H      0.000000       0.000000       0.690000 
+end
+
+basis
+  core None
+  type DZP
+end
+
+symmetry nosym
+
+totalenergy
+
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.out b/example/single_point/plams_workdir/HH_dzp/HH_dzp.out
new file mode 100644
index 00000000..e69de29b
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.run b/example/single_point/plams_workdir/HH_dzp/HH_dzp.run
new file mode 100755
index 00000000..24443565
--- /dev/null
+++ b/example/single_point/plams_workdir/HH_dzp/HH_dzp.run
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+$AMSBIN/adf <"HH_dzp.in"
+
diff --git a/example/single_point/plams_workdir/logfile b/example/single_point/plams_workdir/logfile
new file mode 100644
index 00000000..5c60a6b0
--- /dev/null
+++ b/example/single_point/plams_workdir/logfile
@@ -0,0 +1,14 @@
+[13:43:29] Running PLAMS located in /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams
+[13:43:29] Using Python 3.8.0 located in /home/nico/anaconda3/envs/qmctorch/bin/python
+[13:43:29] PLAMS defaults were loaded from /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams/plams_defaults
+[13:43:29] PLAMS environment initialized
+[13:43:29] PLAMS working folder: /home/nico/QMCTorch/example/single_point/plams_workdir
+[13:43:29] JOB HH_dzp STARTED
+[13:43:29] Starting HH_dzp.prerun()
+[13:43:29] HH_dzp.prerun() finished
+[13:43:29] JOB HH_dzp RUNNING
+[13:43:29] Executing HH_dzp.run
+[13:43:29] Execution of HH_dzp.run finished with returncode 127
+[13:43:29] WARNING: Job HH_dzp finished with nonzero return code
+[13:43:29] WARNING: Main KF file HH_dzp.t21 not present in /home/nico/QMCTorch/example/single_point/plams_workdir/HH_dzp
+[13:43:29] JOB HH_dzp CRASHED
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 0f2f0698..e40a9d89 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -19,6 +19,7 @@ def __init__(self,
                  ndim: int = 3,
                  init: Dict = {'min': -5, 'max': 5},
                  move: Dict = {'type': 'all-elec', 'proba': 'normal'},
+                 logspace: bool = False,
                  cuda: bool = False):
         """Metropolis Hasting generator
 
@@ -54,6 +55,7 @@ def __init__(self,
                              step_size, ntherm, ndecor,
                              nelec, ndim, init, cuda)
 
+        self.logspace = logspace
         self.configure_move(move)
         self.log_data()
 
@@ -63,6 +65,18 @@ def log_data(self):
         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
+
+        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
@@ -92,7 +106,10 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 self.ntherm = self.nstep + self.ntherm
 
             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
@@ -109,10 +126,15 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                     # 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.] = eps
+                        df = fxn / fx
 
                     # accept the moves
                     index = self._accept(df)
@@ -250,8 +272,13 @@ 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)
+            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/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 10c817ab..f9f16b8a 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -270,7 +270,7 @@ def resample(self, n, pos):
 
         return pos
 
-    def single_point(self, with_tqdm=True, hdf5_group='single_point'):
+    def single_point(self, with_tqdm=True, logspace=False, hdf5_group='single_point'):
         """Performs a single point calculatin
 
         Args:
@@ -294,7 +294,8 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
         with grad_mode:
 
             #  get the position and put to gpu if necessary
-            pos = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
+            pos = self.sampler(
+                self.wf.pdf, with_tqdm=with_tqdm, logspace=logspace)
             if self.wf.cuda and pos.device.type == 'cpu':
                 pos = pos.to(self.device)
 
diff --git a/tests/sampler/test_metropolis.py b/tests/sampler/test_metropolis.py
index 30ee9d2d..49ccf446 100644
--- a/tests/sampler/test_metropolis.py
+++ b/tests/sampler/test_metropolis.py
@@ -24,6 +24,24 @@ def test_metropolis(self):
                 sampler.configure_move({'type': m, 'proba': p})
                 pos = sampler(self.wf.pdf)
 
+    def test_metropolis_logspace(self):
+        """Test Metropolis sampling in logspace."""
+
+        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})
+                pos = sampler(self.wf.pdf)
+
 
 if __name__ == "__main__":
     unittest.main()

From 1347f7f0297c9e88f9a7ac87cc1bd791815ed5fc Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 17 Jun 2021 14:59:44 +0200
Subject: [PATCH 003/286] fix solver bug

---
 qmctorch/solver/solver_base.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index f9f16b8a..3efd17ad 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -270,7 +270,7 @@ def resample(self, n, pos):
 
         return pos
 
-    def single_point(self, with_tqdm=True, logspace=False, hdf5_group='single_point'):
+    def single_point(self, with_tqdm=True, hdf5_group='single_point'):
         """Performs a single point calculatin
 
         Args:
@@ -295,7 +295,7 @@ def single_point(self, with_tqdm=True, logspace=False, hdf5_group='single_point'
 
             #  get the position and put to gpu if necessary
             pos = self.sampler(
-                self.wf.pdf, with_tqdm=with_tqdm, logspace=logspace)
+                self.wf.pdf, with_tqdm=with_tqdm)
             if self.wf.cuda and pos.device.type == 'cpu':
                 pos = pos.to(self.device)
 

From 2e4326d528e954cd906c88819431e4062b928f9c Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 17 Jun 2021 20:47:46 +0200
Subject: [PATCH 004/286] made mpi4py optional

---
 qmctorch/scf/molecule.py | 1 -
 setup.py                 | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 0ccd846a..3df8f13f 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -3,7 +3,6 @@
 import numpy as np
 from mendeleev import element
 from types import SimpleNamespace
-from mpi4py import MPI
 import h5py
 
 from .calculator.adf import CalculatorADF
diff --git a/setup.py b/setup.py
index 50322317..76912c67 100644
--- a/setup.py
+++ b/setup.py
@@ -44,10 +44,10 @@
                       'scipy', 'tqdm', 'torch',
                       # 'plams@git+https://github.com/SCM-NV/PLAMS@master',
                       'plams',
-                      'pyscf', 'mendeleev', 'twiggy', 'mpi4py'],
+                      'pyscf', 'mendeleev', 'twiggy'],
 
     extras_require={
-        'hpc': ['horovod'],
+        'hpc': ['horovod', 'mpi4py'],
         'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],

From 46dae495fd3c7dbcd7620e9a0f29ae46915d47fe Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Fri, 18 Jun 2021 09:01:01 +0200
Subject: [PATCH 005/286] fix mpi in Molecule

---
 example/horovod/h2.py    |  4 ++--
 qmctorch/scf/molecule.py | 21 +++++++++++++++------
 tests_hvd/test_h2_hvd.py |  3 ++-
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/example/horovod/h2.py b/example/horovod/h2.py
index 2b5ccb1b..ebd427e4 100644
--- a/example/horovod/h2.py
+++ b/example/horovod/h2.py
@@ -21,9 +21,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/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 3df8f13f..dc58f3fc 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -11,13 +11,18 @@
 from ..utils import dump_to_hdf5, load_from_hdf5, bytes2str
 from .. import log
 
+try:
+    from mpi4py import MPI
+except ModuleNotFoundError:
+    log.info('  MPI not found.')
+
 
 class Molecule:
 
     def __init__(self, atom=None, calculator='adf',
                  scf='hf', basis='dzp', unit='bohr',
                  name=None, load=None, save_scf_file=False,
-                 redo_scf=False, rank=0):
+                 redo_scf=False, rank=0, mpi_size=0):
         """Create a molecule in QMCTorch
 
         Args:
@@ -31,6 +36,7 @@ def __init__(self, atom=None, calculator='adf',
             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
             rank (int, optional): Rank of the process. Defaults to 0.
+            mpi_size (int, optional): size of the mpi world
 
         Examples:
             >>> from qmctorch.wavefunction import Molecule
@@ -118,11 +124,14 @@ def __init__(self, atom=None, calculator='adf',
                     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)
+            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):
 
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index a0b2543c..ccd2eb1d 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -33,7 +33,8 @@ def setUp(self):
             unit='bohr',
             calculator='pyscf',
             basis='sto-3g',
-            rank=hvd.local_rank())
+            rank=hvd.local_rank(),
+            mpi_size=hvd.local_size())
 
         # wave function
         self.wf = SlaterJastrow(self.mol, kinetic='jacobi',

From d6612bd574577037b61a94e841ff615475fa5f9a Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 23 Jun 2021 10:27:45 +0200
Subject: [PATCH 006/286] test

---
 setup.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/setup.py b/setup.py
index 76912c67..15dba259 100644
--- a/setup.py
+++ b/setup.py
@@ -53,3 +53,5 @@
                  'coverage', 'coveralls', 'pycodestyle'],
     }
 )
+
+

From d3f9e304111c17b8dfa0f04315ab0a5175368bb2 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 23 Jun 2021 11:43:07 +0200
Subject: [PATCH 007/286] added h5py

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 15dba259..a9ff8e87 100644
--- a/setup.py
+++ b/setup.py
@@ -43,7 +43,7 @@
     install_requires=['matplotlib', 'numpy', 'argparse',
                       'scipy', 'tqdm', 'torch',
                       # 'plams@git+https://github.com/SCM-NV/PLAMS@master',
-                      'plams',
+                      'plams', 'h5py',
                       'pyscf', 'mendeleev', 'twiggy'],
 
     extras_require={

From 30411496e02f4ff44aab57caafd4585dd37978b8 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 23 Jun 2021 11:43:54 +0200
Subject: [PATCH 008/286] Update build.yml

remove h5py and mpi4py from the conda install
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 541cc339..54c49835 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -26,7 +26,7 @@ jobs:
         conda-channels: anaconda
     - run: conda --version
     - run: which python
-    - run: conda install mpi4py h5py pytorch torchvision cpuonly -c pytorch -c conda-forge
+    - run: conda install pytorch torchvision cpuonly -c pytorch -c conda-forge
 
     - name: Install the package
       run: pip install .[test,hpc]

From 725580f66d11f6fdcc590991a8d8e962008e0c2c Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 23 Jun 2021 13:04:35 +0200
Subject: [PATCH 009/286] reverted mpi4py and h5py to conda

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 54c49835..3b08f0da 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -26,7 +26,7 @@ jobs:
         conda-channels: anaconda
     - run: conda --version
     - run: which python
-    - run: conda install pytorch torchvision cpuonly -c pytorch -c conda-forge
+    - run: conda install mpi4py h5py==3.1.0 pytorch torchvision cpuonly -c pytorch -c conda-forge
 
     - name: Install the package
       run: pip install .[test,hpc]

From a6322075a098a26c3dbe2ee955cc94694ed0e90a Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 23 Jun 2021 13:05:06 +0200
Subject: [PATCH 010/286] Update setup.py

---
 setup.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index a9ff8e87..521bcf23 100644
--- a/setup.py
+++ b/setup.py
@@ -43,11 +43,11 @@
     install_requires=['matplotlib', 'numpy', 'argparse',
                       'scipy', 'tqdm', 'torch',
                       # 'plams@git+https://github.com/SCM-NV/PLAMS@master',
-                      'plams', 'h5py',
+                      'plams',
                       'pyscf', 'mendeleev', 'twiggy'],
 
     extras_require={
-        'hpc': ['horovod', 'mpi4py'],
+        'hpc': ['horovod'],
         'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],

From 38a1dc39cc1bf89e20cbf723b36012f59eb986c8 Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 12:29:26 +0200
Subject: [PATCH 011/286] use fft to compute correlation coefficient

---
 qmctorch/utils/stat_utils.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 6daddd8d..f86ddd45 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,5 +1,7 @@
 import numpy as np
 from scipy.optimize import curve_fit
+from torch.fft import fft, ifft
+from torch import conj
 
 
 def blocking(x, block_size, expand=False):
@@ -22,19 +24,17 @@ def blocking(x, block_size, expand=False):
 
 
 def correlation_coefficient(x, norm=True):
-    """Computes the correlation coefficient
+    """Computes the correlation coefficient using the FFT
 
     Args:
         x (np.ndarray): measurement of size [Nsample, Nexperiments]
         norm (bool, optional): [description]. Defaults to True.
     """
 
-    N = x.shape[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)
+    ft = fft(xm)
+    c = ifft(ft * conj(ft)).real
 
     if norm:
         c /= c[0]
@@ -47,13 +47,13 @@ def integrated_autocorrelation_time(correlation_coeff, size_max):
 
     Args:
         correlation_coeff (np.ndarray): coeff size Nsample,Nexp
-        size_max (int): max size 
+        size_max (int): max size
     """
     return 1. + 2. * np.cumsum(correlation_coeff[1:size_max], 0)
 
 
 def fit_correlation_coefficient(coeff):
-    """Fit the correlation coefficient 
+    """Fit the correlation coefficient
        to get the correlation time.
 
     Args:

From 315f4f113f8a549dfb75d2c3f8ce0ee4d02f66b6 Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 14:31:06 +0200
Subject: [PATCH 012/286] use numpy instead of torch

---
 qmctorch/utils/stat_utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index f86ddd45..5904c7d6 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,7 +1,7 @@
 import numpy as np
 from scipy.optimize import curve_fit
-from torch.fft import fft, ifft
-from torch import conj
+from numpy.fft import fft, ifft
+from numpy import conj
 
 
 def blocking(x, block_size, expand=False):

From 7d8f5386a319db87be10da571ce3502f8d21add6 Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 14:56:22 +0200
Subject: [PATCH 013/286] added example, and both methods of calculating
 autocorrelation

---
 example/autocorrelation/h2.py | 48 +++++++++++++++++++++++++++
 qmctorch/utils/plot_data.py   | 61 ++++++++++++++++++++++++-----------
 qmctorch/utils/stat_utils.py  | 19 +++++++++++
 3 files changed, 110 insertions(+), 18 deletions(-)
 create mode 100644 example/autocorrelation/h2.py

diff --git a/example/autocorrelation/h2.py b/example/autocorrelation/h2.py
new file mode 100644
index 00000000..275bc38e
--- /dev/null
+++ b/example/autocorrelation/h2.py
@@ -0,0 +1,48 @@
+import torch
+from torch import optim
+
+from qmctorch.sampler import Metropolis
+from qmctorch.scf import Molecule
+from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.utils import (plot_block, plot_blocking_energy,
+                            plot_correlation_coefficient, plot_walkers_traj)
+from qmctorch.wavefunction import SlaterJastrow
+
+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')
+
+# wave function
+wf = SlaterJastrow(mol, kinetic='auto',
+                   configs='single(2,2)')
+
+# sampler
+sampler = Metropolis(
+    nwalkers=1000,
+    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 = SolverSlaterJastrow(wf=wf, sampler=sampler, optimizer=opt)
+
+pos = solver.sampler(wf.pdf)
+obs = solver.sampling_traj(pos)
+
+plot_correlation_coefficient(obs.local_energy, method='both')
+plot_walkers_traj(obs.local_energy)
+plot_block(obs.local_energy)
+plot_blocking_energy(obs.local_energy, block_size=10)
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 349cc29b..a43ef36a 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -2,7 +2,7 @@
 import numpy as np
 from matplotlib import cm
 
-from .stat_utils import (blocking, correlation_coefficient,
+from .stat_utils import (blocking, correlation_coefficient, correlation_coefficient_sum,
                          fit_correlation_coefficient,
                          integrated_autocorrelation_time)
 
@@ -112,7 +112,7 @@ def plot_walkers_traj(eloc, walkers='mean'):
     plt.show()
 
 
-def plot_correlation_coefficient(eloc, size_max=100):
+def plot_correlation_coefficient(eloc, size_max=100, method=None):
     """Plot the correlation coefficient of the local energy
        and fit the curve to an exp to extract the correlation time.
 
@@ -124,22 +124,47 @@ def plot_correlation_coefficient(eloc, size_max=100):
         np.ndarray, float: correlation coefficients (size_max, Nwalkers), correlation time
     """
 
-    rho = correlation_coefficient(eloc)
-
-    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.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.grid()
-    plt.show()
+    if method != 'both':
+        if method == 'sum':
+            rho = correlation_coefficient_sum(eloc)
+        else:
+            rho = correlation_coefficient(eloc)
+        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.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.grid()
+        plt.show()
+    else:
+        rho = correlation_coefficient_sum(eloc)
+        rho2 = correlation_coefficient(eloc)
+        tau_fit, fitted = fit_correlation_coefficient(
+            rho.mean(1)[:size_max])
+        tau_fit2, fitted2 = fit_correlation_coefficient(
+            rho2.mean(1)[:size_max])
+
+        # plt.plot(rho, alpha=0.25)
+        plt.plot(rho.mean(1), c='black', label='sum')
+        plt.plot(rho2.mean(1), c='blue', label='fft')
+        plt.plot(fitted, '--', c='grey', label='fitted to sum')
+        plt.plot(fitted2, '--', c='red', label='fitted to fft')
+        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.grid()
+        plt.legend()
+        plt.show()
 
     return rho, tau_fit
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 5904c7d6..7e732cc9 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -41,6 +41,25 @@ def correlation_coefficient(x, norm=True):
 
     return c
 
+def correlation_coefficient_sum(x, norm=True):
+    """Computes the correlation coefficient using the FFT
+
+    Args:
+        x (np.ndarray): measurement of size [Nsample, Nexperiments]
+        norm (bool, optional): [description]. Defaults to True.
+    """
+
+    N = x.shape[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)
+    if norm:
+        c /= c[0]
+
+    return c
+
 
 def integrated_autocorrelation_time(correlation_coeff, size_max):
     """Computes the integrated autocorrelation time

From 4833b9e906356623a3f1eb8e8bb89c66e3832a9e Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 18:22:51 +0200
Subject: [PATCH 014/286] fix computing correlation coefficient

---
 example/autocorrelation/h2.py | 13 ++++----
 qmctorch/utils/plot_data.py   | 63 +++++++++++------------------------
 qmctorch/utils/stat_utils.py  | 35 ++++++-------------
 3 files changed, 36 insertions(+), 75 deletions(-)

diff --git a/example/autocorrelation/h2.py b/example/autocorrelation/h2.py
index 275bc38e..cef59fb4 100644
--- a/example/autocorrelation/h2.py
+++ b/example/autocorrelation/h2.py
@@ -4,8 +4,7 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.scf import Molecule
 from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.utils import (plot_block, plot_blocking_energy,
-                            plot_correlation_coefficient, plot_walkers_traj)
+from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
 from qmctorch.wavefunction import SlaterJastrow
 
 torch.manual_seed(0)
@@ -23,7 +22,7 @@
 
 # sampler
 sampler = Metropolis(
-    nwalkers=1000,
+    nwalkers=10,
     nstep=1000,
     ntherm=0,
     ndecor=1,
@@ -42,7 +41,7 @@
 pos = solver.sampler(wf.pdf)
 obs = solver.sampling_traj(pos)
 
-plot_correlation_coefficient(obs.local_energy, method='both')
-plot_walkers_traj(obs.local_energy)
-plot_block(obs.local_energy)
-plot_blocking_energy(obs.local_energy, block_size=10)
+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/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index a43ef36a..9618da58 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -2,7 +2,7 @@
 import numpy as np
 from matplotlib import cm
 
-from .stat_utils import (blocking, correlation_coefficient, correlation_coefficient_sum,
+from .stat_utils import (blocking, correlation_coefficient,
                          fit_correlation_coefficient,
                          integrated_autocorrelation_time)
 
@@ -112,7 +112,7 @@ def plot_walkers_traj(eloc, walkers='mean'):
     plt.show()
 
 
-def plot_correlation_coefficient(eloc, size_max=100, method=None):
+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.
 
@@ -124,47 +124,22 @@ def plot_correlation_coefficient(eloc, size_max=100, method=None):
         np.ndarray, float: correlation coefficients (size_max, Nwalkers), correlation time
     """
 
-    if method != 'both':
-        if method == 'sum':
-            rho = correlation_coefficient_sum(eloc)
-        else:
-            rho = correlation_coefficient(eloc)
-        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.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.grid()
-        plt.show()
-    else:
-        rho = correlation_coefficient_sum(eloc)
-        rho2 = correlation_coefficient(eloc)
-        tau_fit, fitted = fit_correlation_coefficient(
-            rho.mean(1)[:size_max])
-        tau_fit2, fitted2 = fit_correlation_coefficient(
-            rho2.mean(1)[:size_max])
-
-        # plt.plot(rho, alpha=0.25)
-        plt.plot(rho.mean(1), c='black', label='sum')
-        plt.plot(rho2.mean(1), c='blue', label='fft')
-        plt.plot(fitted, '--', c='grey', label='fitted to sum')
-        plt.plot(fitted2, '--', c='red', label='fitted to fft')
-        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.grid()
-        plt.legend()
-        plt.show()
+
+    rho = correlation_coefficient(eloc)
+    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.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.grid()
+    plt.show()
 
     return rho, tau_fit
 
@@ -212,6 +187,8 @@ def plot_integrated_autocorrelation_time(eloc, rho=None, size_max=100, C=5):
     plt.ylabel('IAC')
     plt.show()
 
+    return ii
+
 
 def plot_blocking_energy(eloc, block_size, walkers='mean'):
     """Plot the blocked energy values
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 7e732cc9..8369f8ac 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,6 +1,6 @@
 import numpy as np
 from scipy.optimize import curve_fit
-from numpy.fft import fft, ifft
+from numpy.fft import rfftn, irfftn
 from numpy import conj
 
 
@@ -27,34 +27,17 @@ def correlation_coefficient(x, norm=True):
     """Computes the correlation coefficient using the FFT
 
     Args:
-        x (np.ndarray): measurement of size [Nsample, Nexperiments]
-        norm (bool, optional): [description]. Defaults to True.
-    """
-
-    xm = x-x.mean(0)
-
-    ft = fft(xm)
-    c = ifft(ft * conj(ft)).real
-
-    if norm:
-        c /= c[0]
-
-    return c
-
-def correlation_coefficient_sum(x, norm=True):
-    """Computes the correlation coefficient using the FFT
-
-    Args:
-        x (np.ndarray): measurement of size [Nsample, Nexperiments]
+        x (np.ndarray): measurement of size [MC steps, N walkers]
         norm (bool, optional): [description]. Defaults to True.
     """
 
+    xm = x - x.mean(0)
     N = x.shape[0]
-    xm = x-x.mean(0)
+    s = [2 * N - 1]
 
-    c = np.zeros_like(x)
-    for tau in range(0, N):
-        c[tau] = 1. / (N - tau) * (xm[:N - tau] * xm[tau:]).sum(0)
+    ft1 = rfftn(xm, s=s, axes=[0])
+    ft2 = rfftn(conj(xm[::-1]), s=s, axes=[0])
+    c = irfftn(ft1 * ft2, s=s, axes=[0])[N - 1:]
     if norm:
         c /= c[0]
 
@@ -84,8 +67,10 @@ def fit_correlation_coefficient(coeff):
 
     def fit_exp(x, y):
         """Fit an exponential to the data."""
+
         def func(x, tau):
-            return np.exp(-x/tau)
+            return np.exp(-x / tau)
+
         popt, pcov = curve_fit(func, x, y, p0=(1.))
         return popt[0], func(x, popt)
 

From 0e9ab60376218c74a77258649c02979d1b7cd50d Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 19:00:33 +0200
Subject: [PATCH 015/286] small style changes

---
 qmctorch/utils/plot_data.py  | 3 +--
 qmctorch/utils/stat_utils.py | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 9618da58..1ef0426e 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -124,12 +124,11 @@ def plot_correlation_coefficient(eloc, size_max=100):
         np.ndarray, float: correlation coefficients (size_max, Nwalkers), correlation time
     """
 
-
     rho = correlation_coefficient(eloc)
     tau_fit, fitted = fit_correlation_coefficient(
         rho.mean(1)[:size_max])
 
-    # plt.plot(rho, alpha=0.25)
+    plt.plot(rho, alpha=0.25)
     plt.plot(rho.mean(1), linewidth=3, c='black')
     plt.plot(fitted, '--', c='grey')
     plt.xlim([0, size_max])
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 8369f8ac..8a6c8c0c 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -31,13 +31,14 @@ def correlation_coefficient(x, norm=True):
         norm (bool, optional): [description]. Defaults to True.
     """
 
-    xm = x - x.mean(0)
     N = x.shape[0]
+    xm = x - x.mean(0)
     s = [2 * N - 1]
 
     ft1 = rfftn(xm, s=s, axes=[0])
     ft2 = rfftn(conj(xm[::-1]), s=s, axes=[0])
     c = irfftn(ft1 * ft2, s=s, axes=[0])[N - 1:]
+
     if norm:
         c /= c[0]
 

From 9d6936a9458de02dcf00206da802db1b84c2b2fa Mon Sep 17 00:00:00 2001
From: matthijs <matthijs111@gmail.com>
Date: Thu, 24 Jun 2021 19:26:46 +0200
Subject: [PATCH 016/286] found a way to use scipy after all!

---
 qmctorch/utils/stat_utils.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 8a6c8c0c..11c2dc3d 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,7 +1,6 @@
 import numpy as np
 from scipy.optimize import curve_fit
-from numpy.fft import rfftn, irfftn
-from numpy import conj
+from scipy.signal import fftconvolve
 
 
 def blocking(x, block_size, expand=False):
@@ -33,11 +32,8 @@ def correlation_coefficient(x, norm=True):
 
     N = x.shape[0]
     xm = x - x.mean(0)
-    s = [2 * N - 1]
 
-    ft1 = rfftn(xm, s=s, axes=[0])
-    ft2 = rfftn(conj(xm[::-1]), s=s, axes=[0])
-    c = irfftn(ft1 * ft2, s=s, axes=[0])[N - 1:]
+    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1:]
 
     if norm:
         c /= c[0]

From 27cfb3aee46b41853c3b9d346dd20862e1faa7b0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 5 Jul 2021 13:17:44 +0200
Subject: [PATCH 017/286] removed plams

---
 .../plams_workdir/HH_dzp/HH_dzp.err           |  1 -
 .../plams_workdir/HH_dzp/HH_dzp.in            | 22 -------------------
 .../plams_workdir/HH_dzp/HH_dzp.out           |  0
 .../plams_workdir/HH_dzp/HH_dzp.run           |  4 ----
 example/single_point/plams_workdir/logfile    | 14 ------------
 5 files changed, 41 deletions(-)
 delete mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.err
 delete mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.in
 delete mode 100644 example/single_point/plams_workdir/HH_dzp/HH_dzp.out
 delete mode 100755 example/single_point/plams_workdir/HH_dzp/HH_dzp.run
 delete mode 100644 example/single_point/plams_workdir/logfile

diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.err b/example/single_point/plams_workdir/HH_dzp/HH_dzp.err
deleted file mode 100644
index 7da1a13a..00000000
--- a/example/single_point/plams_workdir/HH_dzp/HH_dzp.err
+++ /dev/null
@@ -1 +0,0 @@
-./HH_dzp.run: 3: ./HH_dzp.run: /adf: not found
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.in b/example/single_point/plams_workdir/HH_dzp/HH_dzp.in
deleted file mode 100644
index d6829107..00000000
--- a/example/single_point/plams_workdir/HH_dzp/HH_dzp.in
+++ /dev/null
@@ -1,22 +0,0 @@
-units
-  length Bohr
-end
-
-XC
-  HartreeFock
-end
-
-atoms
-      1         H      0.000000       0.000000      -0.690000 
-      2         H      0.000000       0.000000       0.690000 
-end
-
-basis
-  core None
-  type DZP
-end
-
-symmetry nosym
-
-totalenergy
-
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.out b/example/single_point/plams_workdir/HH_dzp/HH_dzp.out
deleted file mode 100644
index e69de29b..00000000
diff --git a/example/single_point/plams_workdir/HH_dzp/HH_dzp.run b/example/single_point/plams_workdir/HH_dzp/HH_dzp.run
deleted file mode 100755
index 24443565..00000000
--- a/example/single_point/plams_workdir/HH_dzp/HH_dzp.run
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-
-$AMSBIN/adf <"HH_dzp.in"
-
diff --git a/example/single_point/plams_workdir/logfile b/example/single_point/plams_workdir/logfile
deleted file mode 100644
index 5c60a6b0..00000000
--- a/example/single_point/plams_workdir/logfile
+++ /dev/null
@@ -1,14 +0,0 @@
-[13:43:29] Running PLAMS located in /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams
-[13:43:29] Using Python 3.8.0 located in /home/nico/anaconda3/envs/qmctorch/bin/python
-[13:43:29] PLAMS defaults were loaded from /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams/plams_defaults
-[13:43:29] PLAMS environment initialized
-[13:43:29] PLAMS working folder: /home/nico/QMCTorch/example/single_point/plams_workdir
-[13:43:29] JOB HH_dzp STARTED
-[13:43:29] Starting HH_dzp.prerun()
-[13:43:29] HH_dzp.prerun() finished
-[13:43:29] JOB HH_dzp RUNNING
-[13:43:29] Executing HH_dzp.run
-[13:43:29] Execution of HH_dzp.run finished with returncode 127
-[13:43:29] WARNING: Job HH_dzp finished with nonzero return code
-[13:43:29] WARNING: Main KF file HH_dzp.t21 not present in /home/nico/QMCTorch/example/single_point/plams_workdir/HH_dzp
-[13:43:29] JOB HH_dzp CRASHED

From fa85bc124bd2ff16cc0162923e07e0d92925e8fa Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <n.renaud@esciencecenter.nl>
Date: Wed, 7 Jul 2021 14:50:50 +0200
Subject: [PATCH 018/286] replaced dataloader

---
 qmctorch/solver/solver_slater_jastrow.py | 14 +++++++-----
 qmctorch/utils/__init__.py               |  4 ++--
 qmctorch/utils/torch_utils.py            | 28 ++++++++++++++++++++++--
 3 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 8aab7795..ee5b759e 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -2,10 +2,10 @@
 from time import time
 
 import torch
-from torch.utils.data import DataLoader
+# from torch.utils.data import DataLoader
 from qmctorch.utils import (DataSet, Loss,
                             OrthoReg, add_group_attr,
-                            dump_to_hdf5)
+                            dump_to_hdf5, DataLoader)
 
 from .. import log
 from .solver_base import SolverBase
@@ -279,9 +279,10 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         self.save_sampling_parameters(pos)
 
         # create the data loader
-        self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(
-            self.dataset, batch_size=batchsize)
+        # self.dataset = DataSet(pos)
+        # self.dataloader = DataLoader(
+        #     self.dataset, batch_size=batchsize)
+        self.dataloader = DataLoader(pos, batch_size=batchsize)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -359,7 +360,8 @@ def run_epochs(self, nepoch):
             self.print_observable(cumulative_loss, verbose=False)
 
             # resample the data
-            self.dataset.data = self.resample(n, self.dataset.data)
+            # self.dataset.data = self.resample(n, self.dataset.data)
+            self.dataloader.data = self.resample(n, self.dataloader.data)
 
             # scheduler step
             if self.scheduler is not None:
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index aa7486ab..821f914a 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -12,7 +12,7 @@
                         plot_walkers_traj)
 from .stat_utils import (blocking, correlation_coefficient,
                          integrated_autocorrelation_time)
-from .torch_utils import (DataSet, Loss, OrthoReg, fast_power,
+from .torch_utils import (DataSet, DataLoader, Loss, OrthoReg, fast_power,
                           set_torch_double_precision,
                           set_torch_single_precision,
                           diagonal_hessian, gradients)
@@ -23,7 +23,7 @@
            'plot_autocorrelation',
            'set_torch_double_precision',
            'set_torch_single_precision',
-           'DataSet', 'Loss', 'OrthoReg',
+           'DataSet', 'Loss', 'OrthoReg', 'DataLoader',
            'dump_to_hdf5', 'load_from_hdf5',
            'bytes2str',
            'register_extra_attributes',
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 60e5b0e8..54ad5742 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,8 +1,8 @@
 import torch
 from torch import nn
-from torch.autograd import grad
+from torch.autograd import grad, Variable
 from torch.utils.data import Dataset
-
+from math import ceil
 
 def set_torch_double_precision():
     """Set the default precision to double for all torch tensors."""
@@ -128,6 +128,30 @@ def __getitem__(self, index):
         """
         return self.data[index, :]
 
+class DataLoader():
+    
+    def __init__(self, data, batch_size):
+        self.data = data
+        self.len = len(data)
+        self.nbatch = ceil(self.len/batch_size)
+        self.count=0
+        self.batch_size = batch_size
+        
+    def __iter__(self):
+        self.count = 0
+        return self
+    
+    def __next__(self):
+        if self.count < self.nbatch-1:
+            out = self.data[self.count*self.batch_size:(self.count+1)*self.batch_size]
+            self.count += 1
+            return out
+        elif self.count == self.nbatch-1:
+            out = self.data[self.count*self.batch_size:]
+            self.count += 1
+            return out
+        else:
+            raise StopIteration
 
 class Loss(nn.Module):
 

From 82e11ce068fcd667ee51c649f3e2bd5a01f03163 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <n.renaud@esciencecenter.nl>
Date: Wed, 7 Jul 2021 15:31:38 +0200
Subject: [PATCH 019/286] dataset

---
 qmctorch/solver/solver_base.py | 2 +-
 qmctorch/utils/torch_utils.py  | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 3efd17ad..06fdbed2 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -262,7 +262,7 @@ def resample(self, n, pos):
                 # sample and update the dataset
                 pos = self.sampler(
                     self.wf.pdf, pos=pos, with_tqdm=False)
-                self.dataloader.dataset.data = pos
+                self.dataloader.dataset = pos
 
             # update the weight of the loss if needed
             if self.loss.use_weight:
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 54ad5742..1297a548 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -131,7 +131,7 @@ def __getitem__(self, index):
 class DataLoader():
     
     def __init__(self, data, batch_size):
-        self.data = data
+        self.dataset = data
         self.len = len(data)
         self.nbatch = ceil(self.len/batch_size)
         self.count=0
@@ -143,11 +143,11 @@ def __iter__(self):
     
     def __next__(self):
         if self.count < self.nbatch-1:
-            out = self.data[self.count*self.batch_size:(self.count+1)*self.batch_size]
+            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.data[self.count*self.batch_size:]
+            out = self.dataset[self.count*self.batch_size:]
             self.count += 1
             return out
         else:

From ec817cb9836610373014c2bf461c90d1ea03335d Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <n.renaud@esciencecenter.nl>
Date: Wed, 7 Jul 2021 15:49:51 +0200
Subject: [PATCH 020/286] data loader in solver horovod

---
 .../solver/solver_slater_jastrow_horovod.py    | 18 ++++++++----------
 qmctorch/utils/torch_utils.py                  |  9 +++++++--
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow_horovod.py b/qmctorch/solver/solver_slater_jastrow_horovod.py
index e8f77620..44e1a091 100644
--- a/qmctorch/solver/solver_slater_jastrow_horovod.py
+++ b/qmctorch/solver/solver_slater_jastrow_horovod.py
@@ -2,9 +2,9 @@
 from types import SimpleNamespace
 
 import torch
-from torch.utils.data import DataLoader
+# from torch.utils.data import DataLoader
 
-from qmctorch.utils import (DataSet, Loss, OrthoReg, add_group_attr,
+from qmctorch.utils import (DataLoader, DataSet, Loss, OrthoReg, add_group_attr,
                             dump_to_hdf5)
 
 from .. import log
@@ -129,16 +129,14 @@ def run(self, nepoch, batchsize=None, loss='energy',
             self.sampler.nwalkers = pos.shape[0]
 
         # create the data loader
-        self.dataset = DataSet(pos)
+        # self.dataset = DataSet(pos)
 
-        if self.cuda:
-            kwargs = {'num_workers': num_threads, 'pin_memory': True}
-        else:
-            kwargs = {'num_workers': num_threads}
+        # 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)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=True)
         min_loss = 1E3
 
         for n in range(nepoch):
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 1297a548..7bb293a1 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -130,8 +130,13 @@ def __getitem__(self, index):
 
 class DataLoader():
     
-    def __init__(self, data, batch_size):
-        self.dataset = data
+    def __init__(self, data, batch_size, pin_memory=False):
+        
+        if pin_memory:
+            self.dataset = data.pin_memory()
+        else:
+            self.dataset = data
+
         self.len = len(data)
         self.nbatch = ceil(self.len/batch_size)
         self.count=0

From ee06a593aa98539ffe9c687e6b172ecfed8e80a5 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <n.renaud@esciencecenter.nl>
Date: Wed, 7 Jul 2021 16:05:14 +0200
Subject: [PATCH 021/286] pin memory

---
 qmctorch/solver/solver_slater_jastrow.py         | 2 +-
 qmctorch/solver/solver_slater_jastrow_horovod.py | 8 +-------
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index ee5b759e..278940b6 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -282,7 +282,7 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         # self.dataset = DataSet(pos)
         # self.dataloader = DataLoader(
         #     self.dataset, batch_size=batchsize)
-        self.dataloader = DataLoader(pos, 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)
diff --git a/qmctorch/solver/solver_slater_jastrow_horovod.py b/qmctorch/solver/solver_slater_jastrow_horovod.py
index 44e1a091..bcc96010 100644
--- a/qmctorch/solver/solver_slater_jastrow_horovod.py
+++ b/qmctorch/solver/solver_slater_jastrow_horovod.py
@@ -130,13 +130,7 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
         # 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(pos, batch_size=batchsize, pin_memory=True)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
         min_loss = 1E3
 
         for n in range(nepoch):

From 64e01800af80a8879613e8c509c96b8d80474856 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <n.renaud@esciencecenter.nl>
Date: Wed, 7 Jul 2021 16:19:14 +0200
Subject: [PATCH 022/286] fix resampling call in solver

---
 qmctorch/solver/solver_slater_jastrow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 278940b6..9b2814ee 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -361,7 +361,7 @@ def run_epochs(self, nepoch):
 
             # resample the data
             # self.dataset.data = self.resample(n, self.dataset.data)
-            self.dataloader.data = self.resample(n, self.dataloader.data)
+            self.dataloader.dataset = self.resample(n, self.dataloader.dataset)
 
             # scheduler step
             if self.scheduler is not None:

From f0515f73d7fcb391a5cf44fc93167f01537dc5a2 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 8 Jul 2021 11:17:11 +0200
Subject: [PATCH 023/286] clean files

---
 qmctorch/solver/solver_slater_jastrow.py      | 13 ++++-------
 .../solver/solver_slater_jastrow_horovod.py   |  7 +++---
 qmctorch/utils/torch_utils.py                 | 23 ++++++++++++++-----
 3 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 9b2814ee..ce8f71e0 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -2,8 +2,7 @@
 from time import time
 
 import torch
-# from torch.utils.data import DataLoader
-from qmctorch.utils import (DataSet, Loss,
+from qmctorch.utils import (Loss,
                             OrthoReg, add_group_attr,
                             dump_to_hdf5, DataLoader)
 
@@ -279,10 +278,8 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         self.save_sampling_parameters(pos)
 
         # 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)
+        self.dataloader = DataLoader(
+            pos, batch_size=batchsize, pin_memory=self.cuda)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -360,8 +357,8 @@ def run_epochs(self, nepoch):
             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)
+            self.dataloader.dataset = self.resample(
+                n, self.dataloader.dataset)
 
             # scheduler step
             if self.scheduler is not None:
diff --git a/qmctorch/solver/solver_slater_jastrow_horovod.py b/qmctorch/solver/solver_slater_jastrow_horovod.py
index bcc96010..bb6a9226 100644
--- a/qmctorch/solver/solver_slater_jastrow_horovod.py
+++ b/qmctorch/solver/solver_slater_jastrow_horovod.py
@@ -2,9 +2,7 @@
 from types import SimpleNamespace
 
 import torch
-# from torch.utils.data import DataLoader
-
-from qmctorch.utils import (DataLoader, DataSet, Loss, OrthoReg, add_group_attr,
+from qmctorch.utils import (DataLoader, Loss, OrthoReg, add_group_attr,
                             dump_to_hdf5)
 
 from .. import log
@@ -130,7 +128,8 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
         # create the data loader
         # self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
+        self.dataloader = DataLoader(
+            pos, batch_size=batchsize, pin_memory=self.cuda)
         min_loss = 1E3
 
         for n in range(nepoch):
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 7bb293a1..04dc8ce4 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -4,6 +4,7 @@
 from torch.utils.data import Dataset
 from math import ceil
 
+
 def set_torch_double_precision():
     """Set the default precision to double for all torch tensors."""
     torch.set_default_dtype = torch.float64
@@ -128,10 +129,18 @@ def __getitem__(self, index):
         """
         return self.data[index, :]
 
+
 class DataLoader():
-    
+
     def __init__(self, data, batch_size, pin_memory=False):
-        
+        """Simple DataLoader to replace toch 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.
+        """
+
         if pin_memory:
             self.dataset = data.pin_memory()
         else:
@@ -139,16 +148,17 @@ def __init__(self, data, batch_size, pin_memory=False):
 
         self.len = len(data)
         self.nbatch = ceil(self.len/batch_size)
-        self.count=0
+        self.count = 0
         self.batch_size = batch_size
-        
+
     def __iter__(self):
         self.count = 0
         return self
-    
+
     def __next__(self):
         if self.count < self.nbatch-1:
-            out = self.dataset[self.count*self.batch_size:(self.count+1)*self.batch_size]
+            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:
@@ -158,6 +168,7 @@ def __next__(self):
         else:
             raise StopIteration
 
+
 class Loss(nn.Module):
 
     def __init__(

From c5dc1c21919a7872770fef506ce701ffb913501f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Fri, 9 Jul 2021 17:12:29 +0200
Subject: [PATCH 024/286] install

---
 .github/workflows/build.yml | 2 +-
 setup.py                    | 5 +----
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3b08f0da..ad03a614 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -26,7 +26,7 @@ jobs:
         conda-channels: anaconda
     - run: conda --version
     - run: which python
-    - run: conda install mpi4py h5py==3.1.0 pytorch torchvision cpuonly -c pytorch -c conda-forge
+    - run: conda install rdkit mpi4py h5py==3.1.0 pytorch torchvision cpuonly -c pytorch -c conda-forge
 
     - name: Install the package
       run: pip install .[test,hpc]
diff --git a/setup.py b/setup.py
index 521bcf23..c0f6d2c6 100644
--- a/setup.py
+++ b/setup.py
@@ -41,8 +41,7 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch',
-                      # 'plams@git+https://github.com/SCM-NV/PLAMS@master',
+                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
                       'plams',
                       'pyscf', 'mendeleev', 'twiggy'],
 
@@ -53,5 +52,3 @@
                  'coverage', 'coveralls', 'pycodestyle'],
     }
 )
-
-

From 40ae6717b217d5aebf16e44c87574f026bcfda54 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Fri, 9 Jul 2021 23:52:04 +0200
Subject: [PATCH 025/286] started jastrow graph

---
 ...jastrow_factor_electron_electron_nuclei.py |   3 +
 .../jastrows/graph/jastrow_graph.py           | 179 ++++++++++++++++++
 2 files changed, 182 insertions(+)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/jastrow_graph.py

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..bffb84db 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
@@ -21,6 +21,9 @@ 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.
         """
 
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
new file mode 100644
index 00000000..05d2cb66
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -0,0 +1,179 @@
+import torch
+from torch import nn
+from ..distance.electron_electron_distance import ElectronElectronDistance
+from ..distance.electron_nuclei_distance import ElectronNucleiDistance
+
+
+class JastrowFactorGraph(nn.Module):
+
+    def __init__(self, nup, ndown,
+                 atomic_pos,
+                 network,
+                 network_kwargs={},
+                 cuda=False):
+        """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
+            network (dgl model): graph network of the factor
+            network_kwargs (dict, optional): Argument of the graph network. Defaults to {}.
+            cuda (bool, optional): use cuda. Defaults to False.
+        """
+
+        super().__init__()
+
+        self.nup = nup
+        self.ndown = ndown
+        self.nelec = nup + ndown
+        self.ndim = 3
+
+        self.cuda = cuda
+        self.device = torch.device('cpu')
+        if self.cuda:
+            self.device = torch.device('cuda')
+
+        self.atoms = atomic_pos.to(self.device)
+        self.natoms = atomic_pos.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)
+
+        self.model = network(**network_kwargs)
+
+    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) 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]
+
+    def get_mask_tri_up(self):
+        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):
+        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, en_dist):
+        r"""Organize the elec nuc distances
+
+        Args:
+            en_dist (torch.tensor): electron-nuclei distances
+                                    nbatch x nelec x natom or
+                                    nbatch x 3 x nelec x natom (dr)
+
+        Returns:
+            torch.tensor: nbatch x natom x nelec_pair x 2 or
+            torch.tensor: nbatch x 3 x natom x nelec_pair x 2 (dr)
+        """
+        out = en_dist[..., self.index_elec, :]
+        if en_dist.ndim == 3:
+            return out.permute(0, 3, 2, 1)
+        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')
+
+    def assemble_dist(self, pos):
+        """Assemle the different distances for easy calculations
+
+        Args:
+            pos (torch.tensor): Positions of the electrons
+                                  Size : Nbatch, Nelec x Ndim
+
+        Returns:
+            torch.tensor : nbatch, natom, nelec_pair, 3
+
+        """
+
+        # get the elec-elec distance matrix
+        ree = self.extract_tri_up(self.elel_dist(pos))
+        ree = ree.unsqueeze(1).unsqueeze(-1)
+        ree = ree.repeat(1, self.natoms, 1, 1)
+
+        # get the elec-nuc distance matrix
+        ren = self.extract_elec_nuc_dist(self.elnu_dist(pos))
+
+        # cat both
+        return torch.cat((ren, ree), -1)
+
+    def assemble_dist_deriv(self, pos, derivative=1):
+        """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}]
+
+        Args:
+            pos (torch.tensor): Positions of the electrons
+                                  Size : Nbatch, Nelec x Ndim
+
+        Returns:
+            torch.tensor : nbatch, 3 x natom, nelec_pair, 3
+
+        """
+
+        # get the elec-elec distance derivative
+        dree = self.elel_dist(pos, derivative)
+        dree = self.extract_tri_up(dree)
+        dree = dree.unsqueeze(2).unsqueeze(-1)
+        dree = dree.repeat(1, 1, self.natoms, 1, 1)
+
+        # get the elec-nuc distance derivative
+        dren = self.elnu_dist(pos, derivative)
+        dren = self.extract_elec_nuc_dist(dren)
+
+        # assemble
+        return torch.cat((dren, dree), -1)

From f8fd664d2b3ad29563820df88fd73cc8035a901b Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 12 Jul 2021 13:43:39 +0200
Subject: [PATCH 026/286] added graph

---
 .../jastrows/graph/elec_elec_graph.py         | 43 +++++++++++
 .../jastrows/graph/elec_nuc_graph.py          | 74 +++++++++++++++++++
 .../jastrows/graph/jastrow_graph.py           | 17 +++++
 3 files changed, 134 insertions(+)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py

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..2d0841bc
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -0,0 +1,43 @@
+import dgl
+import torch
+
+
+def ElecElecGraph(nelec, nup):
+    """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["features"] = get_elec_elec_ndata(nelec, nup)
+    return graph
+
+
+def get_elec_elec_edges(nelec):
+    """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)
+    return ee_edges
+
+
+def get_elec_elec_ndata(nelec, nup):
+    """Compute the node data of the elec-elec graph
+    """
+
+    ee_ndata = []
+    for i in range(nelec):
+        if i < nup:
+            ee_ndata.append([1])
+        else:
+            ee_ndata.append([-1])
+
+    return torch.tensor(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..300e945c
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -0,0 +1,74 @@
+import dgl
+import torch
+from mendeleev import element
+
+
+def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
+    """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["features"] = get_elec_nuc_ndata(
+        natoms, atom_types, atomic_features, nelec, nup)
+    return graph
+
+
+def get_elec_nuc_edges(natoms, nelec):
+    """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)
+
+    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, atom_types, atomic_features,  nelec, nup):
+    """Compute the node data of the elec-elec graph
+    """
+
+    en_ndata = []
+    for i in range(natoms):
+        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:
+            feat.append(1)
+        else:
+            feat.append(-1)
+        en_ndata.append(feat)
+
+    return en_ndata
+
+
+def get_atomic_features(atom_type, atomic_features):
+    """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/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index 05d2cb66..b08bae4c 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -1,15 +1,21 @@
 import torch
 from torch import nn
+import dgl
+
 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
 
 
 class JastrowFactorGraph(nn.Module):
 
     def __init__(self, nup, ndown,
                  atomic_pos,
+                 atom_types,
                  network,
                  network_kwargs={},
+                 atomic_features=["atomic_number"],
                  cuda=False):
         """Graph Neural Network Jastrow Factor
 
@@ -17,6 +23,7 @@ def __init__(self, nup, ndown,
             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
             network (dgl model): graph network of the factor
             network_kwargs (dict, optional): Argument of the graph network. Defaults to {}.
             cuda (bool, optional): use cuda. Defaults to False.
@@ -34,6 +41,8 @@ def __init__(self, nup, ndown,
         if self.cuda:
             self.device = torch.device('cuda')
 
+        self.atom_types = atom_types
+        self.atomic_features = atomic_features
         self.atoms = atomic_pos.to(self.device)
         self.natoms = atomic_pos.shape[0]
 
@@ -48,8 +57,16 @@ def __init__(self, nup, ndown,
         self.elnu_dist = ElectronNucleiDistance(self.nelec,
                                                 self.atoms, self.ndim)
 
+        # instantiate the model to use
         self.model = network(**network_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 forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
 

From 9378f021f52dba09437400b546444c7fad83abef Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 12 Jul 2021 21:49:31 +0200
Subject: [PATCH 027/286] added graph jastrow

---
 example/jast_graph.py                         |  19 +++
 .../jastrows/graph/elec_elec_graph.py         |   6 +-
 .../jastrows/graph/elec_nuc_graph.py          |  35 ++--
 .../jastrows/graph/jastrow_graph.py           | 157 ++++++++++--------
 .../jastrows/elec_elec/test_pade_jastrow.py   |  24 ++-
 .../jastrows/graph/test_graph_jastrow.py      | 124 ++++++++++++++
 6 files changed, 273 insertions(+), 92 deletions(-)
 create mode 100644 example/jast_graph.py
 create mode 100644 tests/wavefunction/jastrows/graph/test_graph_jastrow.py

diff --git a/example/jast_graph.py b/example/jast_graph.py
new file mode 100644
index 00000000..4df30937
--- /dev/null
+++ b/example/jast_graph.py
@@ -0,0 +1,19 @@
+
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+import torch
+from torch.autograd import grad
+nup = 2
+ndown = 2
+atomic_pos = torch.rand(2, 3)
+atom_types = ["Li", "H"]
+jast = JastrowFactorGraph(nup, ndown,
+                          atomic_pos,
+                          atom_types)
+
+
+pos = torch.rand(10, 12)
+pos.requires_grad = True
+jval = jast(pos)
+
+gval = jast(pos, derivative=1)
+hval = jast(pos, derivative=2)
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 2d0841bc..8f9836fd 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -14,7 +14,7 @@ def ElecElecGraph(nelec, nup):
     """
     edges = get_elec_elec_edges(nelec)
     graph = dgl.graph(edges)
-    graph.ndata["features"] = get_elec_elec_ndata(nelec, nup)
+    graph.ndata["node_types"] = get_elec_elec_ndata(nelec, nup)
     return graph
 
 
@@ -36,8 +36,8 @@ def get_elec_elec_ndata(nelec, nup):
     ee_ndata = []
     for i in range(nelec):
         if i < nup:
-            ee_ndata.append([1])
+            ee_ndata.append(0)
         else:
-            ee_ndata.append([-1])
+            ee_ndata.append(1)
 
     return torch.tensor(ee_ndata)
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 300e945c..58adbc8a 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -15,7 +15,7 @@ def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
     """
     edges = get_elec_nuc_edges(natoms, nelec)
     graph = dgl.graph(edges)
-    graph.ndata["features"] = get_elec_nuc_ndata(
+    graph.ndata["node_types"] = get_elec_nuc_ndata(
         natoms, atom_types, atomic_features, nelec, nup)
     return graph
 
@@ -29,10 +29,10 @@ def get_elec_nuc_edges(natoms, nelec):
             en_edges[0].append(i)
             en_edges[1].append(natoms+j)
 
-    for i in range(natoms-1):
-        for j in range(i+1, natoms):
-            en_edges[0].append(i)
-            en_edges[1].append(j)
+    # 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
 
 
@@ -41,20 +41,29 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
     """
 
     en_ndata = []
+    embed_number = 0
+    atom_dict = {}
+
     for i in range(natoms):
-        feat = get_atomic_features(atom_types[i], atomic_features)
-        feat.append([0])  # spin
-        en_ndata.append(feat)
+        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)
+        # feat = get_atomic_features(None, atomic_features)
         if i < nup:
-            feat.append(1)
+            en_ndata.append(embed_number)
         else:
-            feat.append(-1)
-        en_ndata.append(feat)
+            en_ndata.append(embed_number+1)
 
-    return en_ndata
+    return torch.as_tensor(en_ndata)
 
 
 def get_atomic_features(atom_type, atomic_features):
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index b08bae4c..c67aca4e 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -1,6 +1,8 @@
 import torch
 from torch import nn
+from torch.autograd import grad
 import dgl
+from dgllife.model import MGCNPredictor
 
 from ..distance.electron_electron_distance import ElectronElectronDistance
 from ..distance.electron_nuclei_distance import ElectronNucleiDistance
@@ -13,8 +15,10 @@ class JastrowFactorGraph(nn.Module):
     def __init__(self, nup, ndown,
                  atomic_pos,
                  atom_types,
-                 network,
-                 network_kwargs={},
+                 ee_model=MGCNPredictor,
+                 ee_model_kwargs={},
+                 en_model=MGCNPredictor,
+                 en_model_kwargs={},
                  atomic_features=["atomic_number"],
                  cuda=False):
         """Graph Neural Network Jastrow Factor
@@ -24,8 +28,10 @@ def __init__(self, nup, ndown,
             ndow (int): number of spin down electons
             atomic_pos(torch.tensor): positions of the atoms
             atoms (list): atom type in the molecule
-            network (dgl model): graph network of the factor
-            network_kwargs (dict, optional): Argument of the graph network. Defaults to {}.
+            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 {}.
             cuda (bool, optional): use cuda. Defaults to False.
         """
 
@@ -57,8 +63,15 @@ def __init__(self, nup, ndown,
         self.elnu_dist = ElectronNucleiDistance(self.nelec,
                                                 self.atoms, self.ndim)
 
-        # instantiate the model to use
-        self.model = network(**network_kwargs)
+        # instantiate the ee mode; to use
+        ee_model_kwargs["num_node_types"] = 2
+        ee_model_kwargs["num_edge_types"] = 3
+        self.ee_model = ee_model(**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 = en_model(**en_model_kwargs)
 
         # compute the elec-elec graph
         self.ee_graph = ElecElecGraph(self.nelec, self.nup)
@@ -92,6 +105,67 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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))
+
+        # 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.reshape(-1, 1)
+        batch_en_graph.edata['distance'] = ren
+
+        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:
+            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
+
+        elif derivative == 2:
+            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]
+
+            return hval.reshape(
+                nbatch, self.nelec, 3).transpose(1, 2).sum(1)
+
     def get_mask_tri_up(self):
         r"""Get the mask to select the triangular up matrix
 
@@ -124,73 +198,10 @@ 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):
-        r"""Organize the elec nuc distances
-
-        Args:
-            en_dist (torch.tensor): electron-nuclei distances
-                                    nbatch x nelec x natom or
-                                    nbatch x 3 x nelec x natom (dr)
-
-        Returns:
-            torch.tensor: nbatch x natom x nelec_pair x 2 or
-            torch.tensor: nbatch x 3 x natom x nelec_pair x 2 (dr)
-        """
-        out = en_dist[..., self.index_elec, :]
-        if en_dist.ndim == 3:
-            return out.permute(0, 3, 2, 1)
-        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')
-
-    def assemble_dist(self, pos):
-        """Assemle the different distances for easy calculations
-
-        Args:
-            pos (torch.tensor): Positions of the electrons
-                                  Size : Nbatch, Nelec x Ndim
-
-        Returns:
-            torch.tensor : nbatch, natom, nelec_pair, 3
-
-        """
-
-        # get the elec-elec distance matrix
-        ree = self.extract_tri_up(self.elel_dist(pos))
-        ree = ree.unsqueeze(1).unsqueeze(-1)
-        ree = ree.repeat(1, self.natoms, 1, 1)
-
-        # get the elec-nuc distance matrix
-        ren = self.extract_elec_nuc_dist(self.elnu_dist(pos))
-
-        # cat both
-        return torch.cat((ren, ree), -1)
-
-    def assemble_dist_deriv(self, pos, derivative=1):
-        """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}]
+    def extract_elec_nuc_dist(self, ren):
+        """reorganizre the elec-nuc distance to load them in the graph
 
         Args:
-            pos (torch.tensor): Positions of the electrons
-                                  Size : Nbatch, Nelec x Ndim
-
-        Returns:
-            torch.tensor : nbatch, 3 x natom, nelec_pair, 3
-
+            ren (torch.tensor): distance elec-nuc [nbatch, nelec, natom]
         """
-
-        # get the elec-elec distance derivative
-        dree = self.elel_dist(pos, derivative)
-        dree = self.extract_tri_up(dree)
-        dree = dree.unsqueeze(2).unsqueeze(-1)
-        dree = dree.repeat(1, 1, self.natoms, 1, 1)
-
-        # get the elec-nuc distance derivative
-        dren = self.elnu_dist(pos, derivative)
-        dren = self.extract_elec_nuc_dist(dren)
-
-        # assemble
-        return torch.cat((dren, dree), -1)
+        return ren.transpose(1, 2).reshape(-1, 1)
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index e7cbe41c..ed894195 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -51,6 +51,22 @@ def setUp(self):
         self.pos = 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_grad_distance(self):
 
         r = self.jastrow.edist(self.pos)
@@ -83,6 +99,7 @@ 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,
@@ -108,6 +125,7 @@ def test_hess_jastrow(self):
 
 if __name__ == "__main__":
     unittest.main()
-    # t = TestPadeJastrow()
-    # t.setUp()
-    # t.test_grad_jastrow()
+    t = TestPadeJastrow()
+    t.setUp()
+    t.test_permutation()
+    t.test_grad_jastrow()
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..0b3a59f0
--- /dev/null
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -0,0 +1,124 @@
+import unittest
+import numpy as np
+import torch
+from torch.autograd import Variable, grad, gradcheck
+
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+
+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 = torch.rand(2, 3)
+
+        self.atom_types = ["Li", "H"]
+        self.jastrow = JastrowFactorGraph(self.nup, self.ndown,
+                                          self.atomic_pos,
+                                          self.atom_types)
+
+        self.nbatch = 5
+
+        self.pos = 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)
+        # print(jval, jval_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)
+        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).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)
+        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()))
+
+
+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()

From c3af14f59f34b76aea167205e23711d84a425a6f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 13 Jul 2021 08:32:01 +0200
Subject: [PATCH 028/286] LongTensor node data

---
 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py | 2 +-
 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py  | 2 +-
 tests/wavefunction/jastrows/graph/test_graph_jastrow.py | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 8f9836fd..85c4ff11 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -40,4 +40,4 @@ def get_elec_elec_ndata(nelec, nup):
         else:
             ee_ndata.append(1)
 
-    return torch.tensor(ee_ndata)
+    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
index 58adbc8a..fb33c061 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -63,7 +63,7 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
         else:
             en_ndata.append(embed_number+1)
 
-    return torch.as_tensor(en_ndata)
+    return torch.LongTensor(en_ndata)
 
 
 def get_atomic_features(atom_type, atomic_features):
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index 0b3a59f0..a459db36 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -74,7 +74,7 @@ def test_sum_grad_jastrow(self):
 
         val = self.jastrow(self.pos)
         dval = self.jastrow(self.pos, derivative=1)
-        print(dval.shape)
+
         dval_grad = grad(
             val,
             self.pos,
@@ -90,7 +90,7 @@ 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,

From 1cf8308a2bd5f93fb2f17a24f5075e2cf36916d6 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 13 Jul 2021 13:22:41 +0200
Subject: [PATCH 029/286] add mgcn locally to fix embedding

---
 .../jastrows/graph/jastrow_graph.py           |   2 +-
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 311 ++++++++++++++++++
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  82 +++++
 .../jastrows/graph/test_graph_jastrow.py      |  25 +-
 5 files changed, 412 insertions(+), 8 deletions(-)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py

diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index c67aca4e..445f9257 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -2,8 +2,8 @@
 from torch import nn
 from torch.autograd import grad
 import dgl
-from dgllife.model import MGCNPredictor
 
+from .mgcn.mgcn_predictor import MGCNPredictor
 from ..distance.electron_electron_distance import ElectronElectronDistance
 from ..distance.electron_nuclei_distance import ElectronNucleiDistance
 from .elec_elec_graph import ElecElecGraph
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
new file mode 100644
index 00000000..018030bf
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import dgl.function as fn
+import torch
+import torch.nn as nn
+
+from dgllife.model.gnn.schnet import RBFExpansion
+
+
+class EdgeEmbedding(nn.Module):
+    """Module for embedding edges.
+
+    Edges whose end nodes have the same combination of types
+    share the same initial embedding.
+
+    Parameters
+    ----------
+    num_types : int
+        Number of edge types to embed.
+    edge_feats : int
+        Size for the edge representations to learn.
+    """
+
+    def __init__(self, num_types, edge_feats):
+        super(EdgeEmbedding, self).__init__()
+        self.embed = nn.Embedding(num_types, edge_feats)
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.embed.reset_parameters()
+
+    def get_edge_types(self, edges):
+        """Generates edge types.
+
+        The edge type is based on the type of the source and destination nodes.
+        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
+
+        To map each pair of node types to a unique number, we use an unordered pairing function.
+        See more details in this discussion:
+        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
+        Note that the number of edge types should be larger than the square of the maximum node
+        type in the dataset.
+
+        Parameters
+        ----------
+        edges : EdgeBatch
+            Container for a batch of edges.
+
+        Returns
+        -------
+        dict
+            Mapping 'type' to the computed edge types.
+        """
+        node_type1 = edges.src['type']
+        node_type2 = edges.dst['type']
+        return {
+            'type': node_type1 * node_type2 +
+            (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+        }
+
+    def forward(self, g, node_types):
+        """Embeds edge types.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+
+        Returns
+        -------
+        float32 tensor of shape (E, edge_feats)
+            Edge representations.
+        """
+        g = g.local_var()
+        g.ndata['type'] = node_types
+        g.apply_edges(self.get_edge_types)
+        return self.embed(g.edata['type'])
+
+
+class VEConv(nn.Module):
+    """Vertex-Edge Convolution in MGCN
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This layer combines both node and edge features in updating node representations.
+
+    Parameters
+    ----------
+    dist_feats : int
+        Size for the expanded distances.
+    feats : int
+        Size for the input and output node and edge representations.
+    update_edge : bool
+        Whether to update edge representations. Default to True.
+    """
+
+    def __init__(self, dist_feats, feats, update_edge=True):
+        super(VEConv, self).__init__()
+
+        self.update_dists = nn.Sequential(
+            nn.Linear(dist_feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats)
+        )
+        if update_edge:
+            self.update_edge_feats = nn.Linear(feats, feats)
+        else:
+            self.update_edge_feats = None
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        for layer in self.update_dists:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+
+        if self.update_edge_feats is not None:
+            self.update_edge_feats.reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features.
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Edge representations, updated if ``update_edge == True`` in initialization.
+        """
+        expanded_dists = self.update_dists(expanded_dists)
+        if self.update_edge_feats is not None:
+            edge_feats = self.update_edge_feats(edge_feats)
+
+        g = g.local_var()
+        g.ndata.update({'hv': node_feats})
+        g.edata.update({'dist': expanded_dists, 'he': edge_feats})
+        g.update_all(fn.u_mul_e('hv', 'dist', 'm_0'),
+                     fn.sum('m_0', 'hv_0'))
+        g.update_all(fn.copy_e('he', 'm_1'), fn.sum('m_1', 'hv_1'))
+        node_feats = g.ndata.pop('hv_0') + g.ndata.pop('hv_1')
+
+        return node_feats, edge_feats
+
+
+class MultiLevelInteraction(nn.Module):
+    """Building block for MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
+    edge features and expanded distances in message passing and updates node and edge
+    representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the input and output node and edge representations.
+    dist_feats : int
+        Size for the expanded distances.
+    """
+
+    def __init__(self, feats, dist_feats):
+        super(MultiLevelInteraction, self).__init__()
+
+        self.project_in_node_feats = nn.Linear(feats, feats)
+        self.conv = VEConv(dist_feats, feats)
+        self.project_out_node_feats = nn.Sequential(
+            nn.Linear(feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats)
+        )
+        self.project_edge_feats = nn.Sequential(
+            nn.Linear(feats, feats),
+            nn.Softplus(beta=0.5, threshold=14)
+        )
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.project_in_node_feats.reset_parameters()
+        self.conv.reset_parameters()
+        for layer in self.project_out_node_feats:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+        self.project_edge_feats[0].reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Updated edge representations.
+        """
+        new_node_feats = self.project_in_node_feats(node_feats)
+        new_node_feats, edge_feats = self.conv(
+            g, new_node_feats, edge_feats, expanded_dists)
+        new_node_feats = self.project_out_node_feats(new_node_feats)
+        node_feats = node_feats + new_node_feats
+
+        edge_feats = self.project_edge_feats(edge_feats)
+
+        return node_feats, edge_feats
+
+
+class MGCNGNN(nn.Module):
+    """MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This class performs message passing in MGCN and returns the updated node representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 30.
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 0.1.
+    """
+
+    def __init__(self, feats=128, n_layers=3, num_node_types=100,
+                 num_edge_types=3000, cutoff=30., gap=0.1):
+        super(MGCNGNN, self).__init__()
+
+        self.node_embed = nn.Embedding(num_node_types, feats)
+        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
+        self.high = cutoff
+        self.gap = gap
+        self.rbf = RBFExpansion(high=cutoff, gap=gap)
+
+        self.gnn_layers = nn.ModuleList()
+        for _ in range(n_layers):
+            self.gnn_layers.append(MultiLevelInteraction(
+                feats, len(self.rbf.centers)))
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.node_embed.reset_parameters()
+        self.edge_embed.reset_parameters()
+        self.rbf.reset_parameters()
+
+        for layer in self.gnn_layers:
+            layer.reset_parameters()
+
+    def forward(self, g, node_types, edge_dists):
+        """Performs message passing and updates node representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (V, feats * (n_layers + 1))
+            Output node representations.
+        """
+
+        node_feats = self.node_embed(node_types)
+        edge_feats = self.edge_embed(g, node_types)
+        expanded_dists = self.rbf(edge_dists)
+
+        all_layer_node_feats = [node_feats]
+        for gnn in self.gnn_layers:
+            node_feats, edge_feats = gnn(
+                g, node_feats, edge_feats, expanded_dists)
+            all_layer_node_feats.append(node_feats)
+        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
new file mode 100644
index 00000000..abaf7153
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import torch.nn as nn
+from dgllife.model.readout import MLPNodeReadout
+from .mgcn import MGCNGNN
+
+
+class MGCNPredictor(nn.Module):
+    """MGCN for for regression and classification on graphs.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    classifier_hidden_feats : int
+        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
+        representations in the classifier. Default to 64.
+    n_tasks : int
+        Number of tasks, which is also the output size. Default to 1.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 5.0
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 1.0
+    predictor_hidden_feats : int
+        Size for hidden representations in the output MLP predictor. Default to 64.
+    """
+
+    def __init__(self, feats=128, n_layers=3, classifier_hidden_feats=64,
+                 n_tasks=1, num_node_types=100, num_edge_types=3000,
+                 cutoff=5.0, gap=1.0, predictor_hidden_feats=64):
+        super(MGCNPredictor, self).__init__()
+
+        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
+            print('classifier_hidden_feats is deprecated and will be removed in the future, '
+                  'use predictor_hidden_feats instead')
+            predictor_hidden_feats = classifier_hidden_feats
+
+        self.gnn = MGCNGNN(feats=feats,
+                           n_layers=n_layers,
+                           num_node_types=num_node_types,
+                           num_edge_types=num_edge_types,
+                           cutoff=cutoff,
+                           gap=gap)
+        self.readout = MLPNodeReadout(node_feats=(n_layers + 1) * feats,
+                                      hidden_feats=predictor_hidden_feats,
+                                      graph_feats=n_tasks,
+                                      activation=nn.Softplus(beta=1, threshold=20))
+
+    def forward(self, g, node_types, edge_dists):
+        """Graph-level regression/soft classification.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (G, n_tasks)
+            Prediction for the graphs in the batch. G for the number of graphs.
+        """
+        node_feats = self.gnn(g, node_types, edge_dists)
+        return self.readout(g, node_feats)
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index a459db36..e973d7e6 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -4,8 +4,9 @@
 from torch.autograd import Variable, grad, gradcheck
 
 from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
 
-torch.set_default_tensor_type(torch.DoubleTensor)
+torch.set_default_tensor_type(torch.FloatTensor)
 
 
 def hess(out, pos):
@@ -46,11 +47,21 @@ def setUp(self):
         self.atom_types = ["Li", "H"]
         self.jastrow = JastrowFactorGraph(self.nup, self.ndown,
                                           self.atomic_pos,
-                                          self.atom_types)
+                                          self.atom_types,
+                                          ee_model=MGCNPredictor,
+                                          ee_model_kwargs={'n_layers': 2,
+                                                           'feats': 32,
+                                                           'cutoff': 5.0,
+                                                           'gap': 1.5},
+                                          en_model=MGCNPredictor,
+                                          en_model_kwargs={'n_layers': 2,
+                                                           'feats': 32,
+                                                           'cutoff': 5.0,
+                                                           'gap': 1.5})
 
         self.nbatch = 5
 
-        self.pos = torch.rand(self.nbatch, self.nelec * 3)
+        self.pos = -1. + 2*torch.rand(self.nbatch, self.nelec * 3)
         self.pos.requires_grad = True
 
     def test_permutation(self):
@@ -67,7 +78,7 @@ def test_permutation(self):
             self.nbatch, self.nelec*3)
 
         jval_xup = self.jastrow(pos_xup)
-        # print(jval, jval_xup)
+        print(jval, jval_xup)
         # assert(torch.allclose(jval, jval_xup))
 
     def test_sum_grad_jastrow(self):
@@ -119,6 +130,6 @@ def test_hess_jastrow(self):
     t = TestGraphJastrow()
     t.setUp()
     t.test_permutation()
-    t.test_grad_jastrow()
-    t.test_sum_grad_jastrow()
-    t.test_hess_jastrow()
+    # t.test_grad_jastrow()
+    # t.test_sum_grad_jastrow()
+    # t.test_hess_jastrow()

From d6d3e58cb601b255f92cf9dcdf93a510d989deab Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 13 Jul 2021 15:15:09 +0200
Subject: [PATCH 030/286] bidirectional graph

---
 .../wavefunction/jastrows/graph/elec_elec_graph.py  |  4 ++++
 .../wavefunction/jastrows/graph/elec_nuc_graph.py   |  4 ++++
 .../wavefunction/jastrows/graph/jastrow_graph.py    |  8 +++++---
 .../jastrows/graph/test_graph_jastrow.py            | 13 ++++++-------
 4 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 85c4ff11..88be8258 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -26,6 +26,10 @@ def get_elec_elec_edges(nelec):
         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
 
 
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index fb33c061..0d6f0f72 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -26,9 +26,13 @@ def get_elec_nuc_edges(natoms, nelec):
     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)
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index 445f9257..68505333 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -109,14 +109,16 @@ def forward(self, pos, derivative=0, sum_grad=True):
         batch_en_graph = dgl.batch([self.en_graph]*nbatch)
 
         # get the elec-elec distance matrix
-        ree = self.extract_tri_up(self.elel_dist(pos))
+        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.reshape(-1, 1)
-        batch_en_graph.edata['distance'] = ren
+        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')
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index e973d7e6..dc454449 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -1,7 +1,7 @@
 import unittest
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 
 from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
 from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
@@ -49,15 +49,15 @@ def setUp(self):
                                           self.atomic_pos,
                                           self.atom_types,
                                           ee_model=MGCNPredictor,
-                                          ee_model_kwargs={'n_layers': 2,
+                                          ee_model_kwargs={'n_layers': 3,
                                                            'feats': 32,
                                                            'cutoff': 5.0,
-                                                           'gap': 1.5},
+                                                           'gap': 1.},
                                           en_model=MGCNPredictor,
-                                          en_model_kwargs={'n_layers': 2,
+                                          en_model_kwargs={'n_layers': 3,
                                                            'feats': 32,
                                                            'cutoff': 5.0,
-                                                           'gap': 1.5})
+                                                           'gap': 1.0})
 
         self.nbatch = 5
 
@@ -78,8 +78,7 @@ def test_permutation(self):
             self.nbatch, self.nelec*3)
 
         jval_xup = self.jastrow(pos_xup)
-        print(jval, jval_xup)
-        # assert(torch.allclose(jval, jval_xup))
+        assert(torch.allclose(jval, jval_xup))
 
     def test_sum_grad_jastrow(self):
 

From 4a05e00fe3c9e0b6f3e5b784b594a21cf3102efa Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 13 Jul 2021 15:38:13 +0200
Subject: [PATCH 031/286] added slater jastrow graph class

---
 .../jastrows/graph/jastrow_graph.py           |  1 +
 qmctorch/wavefunction/slater_jastrow_graph.py | 61 +++++++++++++++++++
 2 files changed, 62 insertions(+)
 create mode 100644 qmctorch/wavefunction/slater_jastrow_graph.py

diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index 68505333..3eb37989 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -32,6 +32,7 @@ def __init__(self, nup, ndown,
             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.
         """
 
diff --git a/qmctorch/wavefunction/slater_jastrow_graph.py b/qmctorch/wavefunction/slater_jastrow_graph.py
new file mode 100644
index 00000000..81e1a9d2
--- /dev/null
+++ b/qmctorch/wavefunction/slater_jastrow_graph.py
@@ -0,0 +1,61 @@
+
+
+import numpy as np
+import torch
+from .slater_jastrow import SlaterJastrow
+
+from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
+from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+
+from .jastrows.graph.jastrow_graph import JastrowFactorGraph
+from .jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+
+
+class SlaterJastrowGraph(SlaterJastrow):
+
+    def __init__(self, mol, configs='ground_state',
+                 kinetic='jacobi',
+                 ee_model=MGCNPredictor,
+                 ee_model_kwargs={},
+                 en_model=MGCNPredictor,
+                 en_model_kwargs={},
+                 atomic_features=["atomic_number"],
+                 cuda=False,
+                 include_all_mo=True):
+        """Implementation of a SlaterJastrow Network using Graph neural network to express the Jastrow.
+
+        Args:
+            mol (qmc.wavefunction.Molecule): a molecule object
+            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
+            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): turns GPU ON/OFF  Defaults to False.
+            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
+                                             popualted in the configs. Defaults to False
+        Examples::
+            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
+            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+        """
+
+        super().__init__(mol, configs, kinetic, None, None, cuda, include_all_mo)
+
+        self.jastrow_type = 'Graph(ee:%s, en:%s)' % (
+            ee_model.__name__, en_model.__name__)
+        self.use_jastrow = True
+        self.jastrow = JastrowFactorGraph(mol.nup, mol.ndown,
+                                          mol.atom_coords, mol.atoms,
+                                          ee_model=ee_model,
+                                          ee_model_kwargs=ee_model_kwargs,
+                                          en_model=en_model,
+                                          en_model_kwargs=en_model_kwargs,
+                                          atomic_features=atomic_features,
+                                          cuda=cuda)
+
+        if self.cuda:
+            self.jastrow = self.jastrow.to(self.device)
+
+        self.log_data()

From 5a67abcc588bd72d8250709ca276eea95c50d179 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 13 Jul 2021 16:48:02 +0200
Subject: [PATCH 032/286] refac jast

---
 qmctorch/wavefunction/__init__.py             |   3 +-
 .../jastrows/graph/jastrow_graph.py           | 110 +++++++---
 qmctorch/wavefunction/slater_jastrow_graph.py |   4 +-
 tests/wavefunction/test_slaterjastrowgraph.py | 188 ++++++++++++++++++
 4 files changed, 276 insertions(+), 29 deletions(-)
 create mode 100644 tests/wavefunction/test_slaterjastrowgraph.py

diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 10ef6fa5..9d7668e5 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,6 +1,6 @@
 __all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterCombinedJastrow',
            'SlaterJastrowBackFlow', 'SlaterOrbitalDependentJastrow',
-           'SlaterCombinedJastrowBackflow']
+           'SlaterCombinedJastrowBackflow', 'SlaterJastrowGraph']
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
@@ -8,3 +8,4 @@
 from .slater_jastrow_backflow import SlaterJastrowBackFlow
 from .slater_combined_jastrow_backflow import SlaterCombinedJastrowBackflow
 from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
+from .slater_jastrow_graph import SlaterJastrowGraph
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index 3eb37989..cab20315 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -137,37 +137,93 @@ def forward(self, pos, derivative=0, sum_grad=True):
             return torch.exp(ee_kernel + en_kernel)
 
         elif derivative == 1:
-            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(
+            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, en_kernel):
+        """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, ee_kernel, en_kernel, sum_grad):
+        """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, ee_kernel, en_kernel, sum_grad=False, return_all=False):
+        """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 grad_val
 
-        elif derivative == 2:
-            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]
-
-            return hval.reshape(
-                nbatch, self.nelec, 3).transpose(1, 2).sum(1)
+            return (jval, grad_val, hval)
+
+        else:
+            return hval
 
     def get_mask_tri_up(self):
         r"""Get the mask to select the triangular up matrix
diff --git a/qmctorch/wavefunction/slater_jastrow_graph.py b/qmctorch/wavefunction/slater_jastrow_graph.py
index 81e1a9d2..2d5c7a19 100644
--- a/qmctorch/wavefunction/slater_jastrow_graph.py
+++ b/qmctorch/wavefunction/slater_jastrow_graph.py
@@ -47,7 +47,9 @@ def __init__(self, mol, configs='ground_state',
             ee_model.__name__, en_model.__name__)
         self.use_jastrow = True
         self.jastrow = JastrowFactorGraph(mol.nup, mol.ndown,
-                                          mol.atom_coords, mol.atoms,
+                                          torch.as_tensor(
+                                              mol.atom_coords),
+                                          mol.atoms,
                                           ee_model=ee_model,
                                           ee_model_kwargs=ee_model_kwargs,
                                           en_model=en_model,
diff --git a/tests/wavefunction/test_slaterjastrowgraph.py b/tests/wavefunction/test_slaterjastrowgraph.py
new file mode 100644
index 00000000..ae217465
--- /dev/null
+++ b/tests/wavefunction/test_slaterjastrowgraph.py
@@ -0,0 +1,188 @@
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction import SlaterJastrowGraph
+from qmctorch.utils import set_torch_double_precision
+from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+
+from torch.autograd import grad, gradcheck, Variable
+
+import numpy as np
+import torch
+import unittest
+
+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 TestSlaterJastrowGraph(unittest.TestCase):
+
+    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)
+
+        self.wf = SlaterJastrowGraph(mol,
+                                     kinetic='auto',
+                                     include_all_mo=False,
+                                     configs='single_double(2,2)',
+                                     ee_model=MGCNPredictor,
+                                     ee_model_kwargs={'n_layers': 3,
+                                                      'feats': 32,
+                                                      'cutoff': 5.0,
+                                                      'gap': 1.},
+                                     en_model=MGCNPredictor,
+                                     en_model_kwargs={'n_layers': 3,
+                                                      'feats': 32,
+                                                      'cutoff': 5.0,
+                                                      'gap': 1.0})
+
+        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):
+        _ = 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()

From ebb9867ea8c97e45f48fdc2bd80a30f7a8b296fd Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 14 Jul 2021 14:47:12 +0200
Subject: [PATCH 033/286] added notebooks

---
 notebooks/GNNJastrow.ipynb    | 213 +++++++++++++++++++
 notebooks/NeuralJastrow.ipynb | 384 ++++++++++++++++++++++++++++++++++
 notebooks/fcjastrow.png       | Bin 0 -> 574072 bytes
 3 files changed, 597 insertions(+)
 create mode 100644 notebooks/GNNJastrow.ipynb
 create mode 100644 notebooks/NeuralJastrow.ipynb
 create mode 100755 notebooks/fcjastrow.png

diff --git a/notebooks/GNNJastrow.ipynb b/notebooks/GNNJastrow.ipynb
new file mode 100644
index 00000000..e16bf31a
--- /dev/null
+++ b/notebooks/GNNJastrow.ipynb
@@ -0,0 +1,213 @@
+{
+ "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": [
+    "# Graph Neural Networks\n",
+    "\n",
+    "There has been a lot of work done on graph neural networks. See for example the Deep Graph Library (https://www.dgl.ai/) and its application to chemistry https://github.com/awslabs/dgl-lifesci \n",
+    "\n",
+    "In particular the paper Molecular Property Prediction: A Multilevel Quantum Interactions Modeling Perspective (https://arxiv.org/abs/1906.11081) already implemented in dgl-lifesci (https://github.com/awslabs/dgl-lifesci/blob/master/examples/README.md) offers an interesting way of extending the defintion of the Jastrow Factors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GNN Jastrow Factors\n",
+    "\n",
+    "\n",
+    "Instead of defining the Electorn-Electron Jastrow factor through the Pade Jastrow or the FullyConnected Netowrk we can consider the different connection graphs and use these graph as an input of graph network. \n",
+    "\n",
+    "\n",
+    "\n",
+    "W can first consider the connection graph between all the elctrons. In this input graph each node represent a given electron and an edge exists between all electron pairs. The distance between two electron can be used as an edge feature to encode the relative positions of the electrons\n",
+    "\n",
+    "We can also consider the connection graphs between the electrons and the nuclei. In this graph each electron is represented by a node and each atom is also represented by a node. Edges exists only between electron and atoms biut not between electron pairs (we can optionally consider edges between nuclei)\n",
+    "\n",
+    "Expressing the structure of the electron/nuclei system as a graph allows expressing different interactions, e.g. elec-elec terms, elec-elec-elec termsn, elec-nuclei, elec-elec-nuclei, etc ... in a very flexible way through convolution over the graphs. (see https://arxiv.org/abs/1906.11081)\n",
+    "\n",
+    "The `JastrowFactorGraph` orchestrate the calculation of such Jastrow factor and accept different graph neural network for the elec-elec graphs and the elec-nuc graphs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph\n",
+    "from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor\n",
+    "\n",
+    "nup, ndown = 2, 2\n",
+    "nelec = nup + ndown\n",
+    "\n",
+    "atom_types = [\"Li\", \"H\"]\n",
+    "atomic_pos = torch.tensor([[0., 0., 0.],\n",
+    "                           [0., 0., 3.015]])\n",
+    "\n",
+    "\n",
+    "jastrow = JastrowFactorGraph(nup, ndown,\n",
+    "                                  atomic_pos,\n",
+    "                                  atom_types,\n",
+    "                                  ee_model=MGCNPredictor,\n",
+    "                                  ee_model_kwargs={'n_layers': 3,\n",
+    "                                                   'feats': 32,\n",
+    "                                                   'cutoff': 5.0,\n",
+    "                                                   'gap': 1.},\n",
+    "                                  en_model=MGCNPredictor,\n",
+    "                                  en_model_kwargs={'n_layers': 3,\n",
+    "                                                   'feats': 32,\n",
+    "                                                   'cutoff': 5.0,\n",
+    "                                                   'gap': 1.0})\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SlaterJastrow wave function with MGCN\n",
+    "\n",
+    "The `SlaterJastrowGraph` class allows using GNN Jastrows in Slater-Jastrow wave function "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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.85928101642664\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.859 Hartree\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : False\n",
+      "INFO:QMCTorch|  Highest MO included : 3\n",
+      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
+      "INFO:QMCTorch|  Number of confs     : 4\n",
+      "INFO:QMCTorch|  Kinetic energy      : auto\n",
+      "INFO:QMCTorch|  Number var  param   : 37\n",
+      "INFO:QMCTorch|  Cuda support        : False\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : Graph(ee:MGCNPredictor, en:MGCNPredictor)\n",
+      "INFO:QMCTorch|  Highest MO included : 3\n",
+      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
+      "INFO:QMCTorch|  Number of confs     : 4\n",
+      "INFO:QMCTorch|  Kinetic energy      : auto\n",
+      "INFO:QMCTorch|  Number var  param   : 56263\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrowGraph\n",
+    "from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor\n",
+    "\n",
+    "\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",
+    "    redo_scf=True)\n",
+    "\n",
+    "wf = SlaterJastrowGraph( mol,\n",
+    "                         kinetic='auto',\n",
+    "                         include_all_mo=False,\n",
+    "                         configs='single_double(2,2)',\n",
+    "                         ee_model=MGCNPredictor,\n",
+    "                         ee_model_kwargs={'n_layers': 3,\n",
+    "                                          'feats': 32,\n",
+    "                                          'cutoff': 5.0,\n",
+    "                                          'gap': 1.},\n",
+    "                         en_model=MGCNPredictor,\n",
+    "                         en_model_kwargs={'n_layers': 3,\n",
+    "                                          'feats': 32,\n",
+    "                                          'cutoff': 5.0,\n",
+    "                                          'gap': 1.0})\n",
+    "\n",
+    "nbatch = 10\n",
+    "pos = torch.rand(nbatch,  wf.nelec*3)\n",
+    "\n",
+    "wfval = wf(pos)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TODO Explore the different architectures of MGCN \n",
+    "\n",
+    "As for the Fully connected networks, it would be great assess the performance of MGCN jastrow factors in predicting the total energy of the test molecules (H2, LiH, Li2, N2). Of course MGCN are only one of the possible options and we can also define new GNN to compute the jastrows."
+   ]
+  },
+  {
+   "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/NeuralJastrow.ipynb b/notebooks/NeuralJastrow.ipynb
new file mode 100644
index 00000000..548ce819
--- /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 = SolverSlaterJastrow(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 0000000000000000000000000000000000000000..ae407e0154164b4636cb2842c1fec393f6183268
GIT binary patch
literal 574072
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
D_$R$z

literal 0
HcmV?d00001


From f018000c4734387b90deca585695677967cd173d Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 17 Aug 2021 11:16:39 +0200
Subject: [PATCH 034/286] create new slater jastrow clas

---
 .../orbitals/atomic_orbitals_backflow.py      |  74 +-
 ...mic_orbitals_orbital_dependent_backflow.py |   9 +-
 .../backflow/backflow_transformation.py       | 305 +++++++-
 .../wavefunction/slater_jastrow_unified.py    | 666 ++++++++++++++++++
 4 files changed, 1023 insertions(+), 31 deletions(-)
 create mode 100644 qmctorch/wavefunction/slater_jastrow_unified.py

diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 7ddf796b..713e5956 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -1,12 +1,10 @@
 import torch
-
 from .atomic_orbitals import AtomicOrbitals
-from .backflow.backflow_transformation import BackFlowTransformation
 
 
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
 
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
+    def __init__(self, mol, backflow, cuda=False):
         """Computes the value of atomic orbitals
 
         Args:
@@ -16,10 +14,7 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=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)
+        self.backflow_trans = backflow
 
     def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
         """Computes the values of the atomic orbitals.
@@ -151,7 +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 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)
@@ -299,13 +294,25 @@ 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)
+
+            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)
+        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))
+            # 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):
         """Computes the positions/distance bewteen elec/atoms
@@ -331,3 +338,42 @@ def _elec_atom_dist(self, pos):
         r = torch.sqrt((xyz*xyz).sum(3))
 
         return xyz, r
+
+    def _elec_ao_dist(self, pos):
+        """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
+        # 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..239bc732 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
@@ -142,8 +142,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)
@@ -213,13 +212,11 @@ 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)
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 16a92dce..30d42d26 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,12 +1,13 @@
 import numpy
 import torch
 from torch import nn
+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, backflow_kernel, backflow_kernel_kwargs={}, orbital_dependent=False, cuda=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,13 +16,21 @@ 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')
         if self.cuda:
@@ -30,18 +39,36 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
     def forward(self, pos, derivative=0):
 
         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')
 
+    def _get_backflow(self, pos):
+        """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):
         """Computes the backflow transformation
 
@@ -70,6 +97,65 @@ def _backflow(self, pos):
 
         return pos.reshape(-1, self.nelec*self.ndim)
 
+    def _backflow_od(self, pos):
+        """Computes the orbital dependent 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]
+        """
+
+        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):
+        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):
         r"""Computes the derivative of the backflow transformation
            wrt the original positions of the electrons
@@ -139,9 +225,87 @@ def _backflow_derivative(self, pos):
 
         # 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
 
-    def _backflow_second_derivative(self, pos):
+        return out.unsqueeze(-1)
+
+    def _backflow_derivative_od(self, pos):
+        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)
+
+        # 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):
         r"""Computes the second derivative of the backflow transformation
            wrt the original positions of the electrons
 
@@ -165,7 +329,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):
+        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)
@@ -224,4 +416,95 @@ def _backflow_second_derivative(self, pos):
 
         # 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):
+        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)
diff --git a/qmctorch/wavefunction/slater_jastrow_unified.py b/qmctorch/wavefunction/slater_jastrow_unified.py
new file mode 100644
index 00000000..bd49bd09
--- /dev/null
+++ b/qmctorch/wavefunction/slater_jastrow_unified.py
@@ -0,0 +1,666 @@
+
+
+import torch
+from scipy.optimize import curve_fit
+from copy import deepcopy
+import matplotlib.pyplot as plt
+import numpy as np
+from torch import nn
+import operator
+
+from .. import log
+
+from .wf_base import WaveFunction
+from .orbitals.atomic_orbitals import AtomicOrbitals
+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
+
+
+class SlaterJastrowUnified(WaveFunction):
+
+    def __init__(self, mol,
+                 jastrow=None,
+                 backflow=None,
+                 configs='ground_state',
+                 kinetic='jacobi',
+                 cuda=False,
+                 include_all_mo=True):
+        """Implementation of the QMC Network.
+
+        Args:
+            mol (qmc.wavefunction.Molecule): a molecule object
+            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
+            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
+            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
+                                             popualted in the configs. Defaults to False
+        Examples::
+            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
+            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+        """
+
+        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)
+
+        # init the mo mixer layer
+        self.init_mo_mixer()
+
+        # 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_scf',
+                                   'mo', 'jastrow',
+                                   'pool', 'fc'])
+
+        self.log_data()
+
+    def init_atomic_orb(self, backflow):
+        """Initialize the atomic orbital layer."""
+        self.backflow = backflow
+        if self.backflow is None:
+            self.ao = AtomicOrbitals(self.mol, self.cuda)
+        else:
+            self.ao = AtomicOrbitalsBackFlow(
+                self.mol, self.backflow, self.cuda)
+
+        if self.cuda:
+            self.ao = self.ao.to(self.device)
+
+    def init_molecular_orb(self, include_all_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
+
+        # scf layer
+        self.mo_scf = nn.Linear(
+            self.mol.basis.nao, self.nmo_opt, bias=False)
+        self.mo_scf.weight = self.get_mo_coeffs()
+        self.mo_scf.weight.requires_grad = False
+
+        # port the layer to cuda if needed
+        if self.cuda:
+            self.mo_scf.to(self.device)
+
+    def init_mo_mixer(self):
+        """Init the mo mixer layer"""
+
+        # mo mixer layer
+        self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
+
+        # init the weight to idenity matrix
+        self.mo.weight = nn.Parameter(
+            torch.eye(self.nmo_opt, self.nmo_opt))
+
+        # put on the card if needed
+        if self.cuda:
+            self.mo.to(self.device)
+
+    def init_config(self, configs):
+        """Initialize the electronic configurations desired in the wave function."""
+
+        # define the SD we want
+        self.orb_confs = OrbitalConfigurations(self.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
+
+    def init_slater_det_calculator(self):
+        """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):
+        """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.)
+        self.fc.weight.data[0][0] = 1.
+
+        # port to card
+        if self.cuda:
+            self.fc = self.fc.to(self.device)
+
+    def init_jastrow(self, jastrow):
+        """Init the jastrow factor calculator"""
+
+        self.jastrow = jastrow
+
+        if self.jastrow is None:
+            self.use_jastrow = False
+
+        else:
+            self.use_jastrow = True
+            self.jastrow_type = self.jastrow.jastrow_kernel.__name__
+
+            if self.cuda:
+                self.jastrow = self.jastrow.to(self.device)
+
+    def init_kinetic_calc(self, kinetic, backflow):
+        """"Init the calculator of the kinetic energies"""
+
+        self.kinetic_method = kinetic
+        if kinetic == 'jacobi':
+            if backflow is None:
+                self.kinetic_energy = self.kinetic_energy_jacobi
+            else:
+                self.kinetic_energy = self.kinetic_energy_jacobi_backflow
+
+    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.
+        C. Filippi, Simple Formalism for Efficient Derivatives .
+
+        .. math::
+             \\frac{\Delta \\Psi(R)}{ \\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\\Delta D_n^u}{D_n^u} + \\frac{\\Delta D_n^d}{D_n^d}) D_n^u D_n^d
+
+        We compute the laplacian of the determinants through the Jacobi formula
+
+        .. math::
+            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A)
+
+        Here A = J(R) phi and therefore :
+
+        .. math::
+            \\Delta A = (\\Delta J) D + 2 \\nabla J \\nabla D + (\\Delta D) J
+        Args:
+            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
+
+        Returns:
+            torch.tensor: values of the kinetic energy at each sampling points
+        """
+
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
+        mo = self.ao2mo(ao)
+        bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
+
+        kin = self.pool.operator(mo, bkin)
+        psi = self.pool(mo)
+        out = self.fc(kin * psi) / self.fc(psi)
+        return out
+
+    def gradients_jacobi(self, x, sum_grad=False, 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})
+
+        The gradients of the wave function
+
+        .. math:
+            \\Psi(R) = J(R) \\sum_n c_n D^{u}_n D^{d}_n = J(R) \\Sigma
+
+        are computed following
+
+        .. math::
+            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \Sigma \\right)
+
+        with
+
+        .. math::
+
+            \\nabla \\Sigma =  \\sum_n c_n (\\frac{\\nabla D^u_n}{D^u_n} + \\frac{\\nabla D^d_n}{D^d_n}) D^u_n D^d_n
+
+        that we compute with the Jacobi formula as:
+
+        .. math::
+
+            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
+
+        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
+        """
+
+        # compute the mo values
+        mo = self.ao2mo(self.ao(x))
+
+        # compute the gradient operator matrix
+        grad_ao = self.ao(x, derivative=1, sum_grad=False)
+
+        # compute the derivatives of the MOs
+        dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
+        dmo = dmo.permute(3, 0, 1, 2)
+
+        # stride the tensor
+        eye = torch.eye(self.nelec).to(self.device)
+        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
+
+        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
+        dmo = dmo.permute(2, 0, 1, 3, 4)
+
+        # flatten to have Nelec*Ndim, Nbatch, Nelec, Nmo
+        dmo = dmo.reshape(-1, *(dmo.shape[2:]))
+
+        # use the Jacobi formula to compute the value
+        # the grad of each determinants and sum up the terms :
+        # Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)
+        grad_dets = self.pool.operator(mo, dmo)
+
+        # compute the determinants
+        # D^u_n D^d_n
+        dets = self.pool(mo)
+
+        # assemble the final values of \nabla \Sigma
+        # \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
+        out = self.fc(grad_dets * dets)
+        out = out.transpose(0, 1).squeeze()
+
+        if self.use_jastrow:
+
+            nbatch = x.shape[0]
+
+            # nbatch x 1
+            jast = self.jastrow(x)
+
+            # nbatch x ndim x nelec
+            grad_jast = self.jastrow(x, derivative=1, sum_grad=False)
+
+            # reorder grad_jast to nbtach x Nelec x Ndim
+            grad_jast = grad_jast.permute(0, 2, 1)
+
+            # compute J(R) (\nabla\Sigma)
+            out = jast*out
+
+            # add the product (\nabla J(R)) \Sigma
+            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
+        if pdf:
+            out = 2 * out * self.fc(dets)
+            if self.use_jastrow:
+                out = out * jast
+
+        return out
+
+    def get_kinetic_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
+        """
+
+        bkin = self.ao2mo(d2ao)
+
+        if self.use_jastrow:
+
+            jast, djast, d2jast = self.jastrow(x,
+                                               derivative=[0, 1, 2],
+                                               sum_grad=False)
+
+            djast = djast.transpose(1, 2) / jast.unsqueeze(-1)
+            d2jast = d2jast / jast
+
+            dmo = self.ao2mo(dao.transpose(2, 3)).transpose(2, 3)
+
+            djast_dmo = (djast.unsqueeze(2) * dmo).sum(-1)
+            d2jast_mo = d2jast.unsqueeze(-1) * mo
+
+            bkin = bkin + 2 * djast_dmo + d2jast_mo
+
+        return -0.5 * bkin
+
+    def kinetic_energy_jacobi_backflow(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_backflow(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')
+
+    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):
+        """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 nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
+
+    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):
+        """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, self.jastrow, backflow=self.backflow,
+                              configs=self.configs_method,
+                              kinetic=self.kinetic_method,
+                              cuda=self.cuda,
+                              include_all_mo=self.include_all_mo)

From f66cbfe0433e0678a02f232d42ce38fb105ea373 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 17 Aug 2021 15:08:28 +0200
Subject: [PATCH 035/286] refactored tests

---
 .../jastrow_factor_electron_electron.py       |  16 +-
 ...jastrow_factor_electron_electron_nuclei.py |  13 +-
 .../jastrow_factor_electron_nuclei.py         |  17 +-
 .../jastrows/jastrow_factor_combined_terms.py |  26 ++-
 .../wavefunction/slater_jastrow_unified.py    |   4 +-
 tests/wavefunction/base_test_cases.py         | 207 ++++++++++++++++++
 .../test_slatercombinedjastrow.py             | 176 +++------------
 tests/wavefunction/test_slaterjastrow.py      | 156 ++-----------
 tests/wavefunction/test_slaterjastrow_cas.py  | 190 ++--------------
 .../test_slaterjastrow_ee_cusp.py             |  20 +-
 .../test_slaterjastrow_generic.py             | 165 +++-----------
 .../test_slaterjastrow_unified.py             |  63 ++++++
 12 files changed, 422 insertions(+), 631 deletions(-)
 create mode 100644 tests/wavefunction/base_test_cases.py
 create mode 100644 tests/wavefunction/test_slaterjastrow_unified.py

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..6b121115 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -6,7 +6,7 @@
 
 class JastrowFactorElectronElectron(nn.Module):
 
-    def __init__(self, nup, ndown,
+    def __init__(self, mol,
                  jastrow_kernel,
                  kernel_kwargs={},
                  orbital_dependent_kernel=False,
@@ -32,9 +32,9 @@ def __init__(self, nup, ndown,
 
         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
@@ -47,10 +47,10 @@ def __init__(self, nup, ndown,
         # kernel function
         if orbital_dependent_kernel:
             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
@@ -61,6 +61,10 @@ def __init__(self, nup, ndown,
                                               scale=scale,
                                               scale_factor=scale_factor)
 
+    def __repr__(self):
+        """representation of the jastrow factor"""
+        return "ee -> " + self.jastrow_kernel.__class__.__name__
+
     def get_mask_tri_up(self):
         r"""Get the mask to select the triangular up matrix
 
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 bffb84db..2a5482bd 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
@@ -9,7 +9,7 @@
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
 
-    def __init__(self, nup, ndown, atomic_pos,
+    def __init__(self, mol,
                  jastrow_kernel,
                  kernel_kwargs={},
                  cuda=False):
@@ -29,21 +29,22 @@ 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')
         if self.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,
+        self.jastrow_kernel = jastrow_kernel(mol.nup, mol.ndown,
                                              atomic_pos,
                                              cuda,
                                              **kernel_kwargs)
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..1bae2032 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -5,7 +5,7 @@
 
 class JastrowFactorElectronNuclei(nn.Module):
 
-    def __init__(self, nup, ndown, atomic_pos,
+    def __init__(self, mol,
                  jastrow_kernel,
                  kernel_kwargs={},
                  cuda=False):
@@ -23,21 +23,22 @@ 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')
         if self.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,
+        self.jastrow_kernel = jastrow_kernel(mol.nup,  mol.ndown,
                                              atomic_pos, cuda,
                                              **kernel_kwargs)
 
@@ -48,6 +49,10 @@ def __init__(self, nup, ndown, atomic_pos,
         self.edist = ElectronNucleiDistance(
             self.nelec, self.atoms, self.ndim)
 
+    def __repr__(self):
+        """representation of the jastrow factor"""
+        return "en -> " + self.jastrow_kernel.__class__.__name__
+
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
 
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index 3f93394f..60b4e642 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -14,7 +14,7 @@
 
 class JastrowFactorCombinedTerms(nn.Module):
 
-    def __init__(self, nup, ndown, atomic_pos,
+    def __init__(self, mol,
                  jastrow_kernel={
                      'ee': PadeJastrowKernelElecElec,
                      'en': PadeJastrowKernelElecNuc,
@@ -36,10 +36,10 @@ 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_kernel_dict = jastrow_kernel
         self.jastrow_terms = []
 
         # sanitize the dict
@@ -53,28 +53,36 @@ def __init__(self, nup, ndown, atomic_pos,
 
         if jastrow_kernel['ee'] is not None:
 
-            self.jastrow_terms.append(JastrowFactorElectronElectron(nup, ndown,
+            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(nup, ndown,
-                                                                  atomic_pos,
+            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(nup, ndown,
-                                                                          atomic_pos,
+            self.jastrow_terms.append(JastrowFactorElectronElectronNuclei(mol,
                                                                           jastrow_kernel['een'],
                                                                           jastrow_kernel_kwargs['een'],
                                                                           cuda=cuda))
         self.nterms = len(self.jastrow_terms)
 
+    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__)
+
+        return " + ".join(out)
+
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
 
diff --git a/qmctorch/wavefunction/slater_jastrow_unified.py b/qmctorch/wavefunction/slater_jastrow_unified.py
index bd49bd09..8c07a261 100644
--- a/qmctorch/wavefunction/slater_jastrow_unified.py
+++ b/qmctorch/wavefunction/slater_jastrow_unified.py
@@ -177,12 +177,12 @@ def init_jastrow(self, jastrow):
 
         else:
             self.use_jastrow = True
-            self.jastrow_type = self.jastrow.jastrow_kernel.__name__
+            self.jastrow_type = self.jastrow.__repr__()
 
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
 
-    def init_kinetic_calc(self, kinetic, backflow):
+    def init_kinetic(self, kinetic, backflow):
         """"Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
new file mode 100644
index 00000000..4b63d7d2
--- /dev/null
+++ b/tests/wavefunction/base_test_cases.py
@@ -0,0 +1,207 @@
+import unittest
+from torch.autograd import grad, gradcheck, Variable
+
+import numpy as np
+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"""
+            self.pos = None
+            self.wf = None
+            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_grad_wf(self):
+            pass
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index a29d9ac5..8ddd8a5b 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -1,43 +1,22 @@
+import unittest
+import numpy as np
+import torch
+
+from base_test_cases import BaseTestCases
+
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterCombinedJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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, FullyConnectedJastrowKernel
-from torch.autograd import grad, gradcheck, Variable
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import BoysHandyJastrowKernel
 
-import numpy as np
-import torch
-import unittest
 
 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 TestSlaterCombinedJastrow(unittest.TestCase):
+class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -54,18 +33,21 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
-        self.wf = SlaterCombinedJastrow(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': {}})
+        jastrow = JastrowFactorCombinedTerms(mol,
+                                             jastrow_kernel={
+                                                 'ee': PadeJastrowKernelElecElec,
+                                                 'en': PadeJastrowKernelElecNuc,
+                                                 'een': BoysHandyJastrowKernel},
+                                             jastrow_kernel_kwargs={
+                                                 'ee': {'w': 1.},
+                                                 'en': {'w': 1.},
+                                                 '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
@@ -74,114 +56,6 @@ def setUp(self):
             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.py b/tests/wavefunction/test_slaterjastrow.py
index 9c297f89..c6407fd8 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -1,41 +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
 
-torch.set_default_tensor_type(torch.DoubleTensor)
 
+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]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.utils import set_torch_double_precision
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrow(unittest.TestCase):
+class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -52,10 +38,20 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
+
         self.wf = SlaterJastrow(mol,
                                 kinetic='auto',
                                 include_all_mo=False,
-                                configs='single_double(2,2)')
+                                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
@@ -64,114 +60,6 @@ def setUp(self):
             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_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index c6e8543d..b2a9e54a 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -1,41 +1,23 @@
-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
+from mendeleev.tables import Base
 import numpy as np
+from numpy.lib.stride_tricks import _broadcast_arrays_dispatcher
 import torch
-import unittest
-
-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)
+from base_test_cases import BaseTestCases
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+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
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestOrbitalWF(unittest.TestCase):
+class TestSlaterJastrowCAS(BaseTestCases.WaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -52,10 +34,15 @@ def setUp(self):
             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)')
+                                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
@@ -65,149 +52,6 @@ def setUp(self):
             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 e6e05a67..8655a044 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -1,11 +1,16 @@
+import unittest
+import numpy as np
+import torch
+
+
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 FullyConnectedJastrowKernel, PadeJastrowKernel
+
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -27,8 +32,11 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
+
         self.wf = SlaterJastrow(mol,
-                                jastrow_kernel=FullyConnectedJastrowKernel,
+                                jastrow=jastrow,
                                 kinetic='jacobi',
                                 include_all_mo=True,
                                 configs='ground_state')
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 39f0550e..6b08b282 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -1,43 +1,26 @@
-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
-
 
-torch.set_default_tensor_type(torch.DoubleTensor)
+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]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.utils import set_torch_double_precision
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestGenericJastrowWF(unittest.TestCase):
+class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -48,128 +31,34 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 1.',
+            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)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
+
         self.wf = SlaterJastrow(mol,
                                 kinetic='auto',
-                                configs='ground_state',
-                                jastrow_kernel=FullyConnectedJastrowKernel)
+                                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_unified.py b/tests/wavefunction/test_slaterjastrow_unified.py
new file mode 100644
index 00000000..7e08102a
--- /dev/null
+++ b/tests/wavefunction/test_slaterjastrow_unified.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_unified import SlaterJastrowUnified as 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
+
+from qmctorch.utils import set_torch_double_precision
+
+
+torch.set_default_tensor_type(torch.DoubleTensor)
+
+
+class TestSlaterJastrow(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)
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
+
+        # define backflow trans
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
+
+        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.requires_grad = True
+
+
+if __name__ == "__main__":
+    unittest.main()

From f6c2666e050b724b1b2578994af5186336ee24de Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 17 Aug 2021 17:03:38 +0200
Subject: [PATCH 036/286] working the refactoring

---
 notebooks/test.ipynb                          |   0
 .../orbitals/atomic_orbitals_backflow.py      |   6 +-
 .../wavefunction/slater_jastrow_unified.py    |   3 +
 .../test_backflow_transformation_pyscf.py     |   4 +-
 ...dependent_backflow_transformation_pyscf.py |  17 +-
 .../test_backflow_ao_derivatives_pyscf.py     |   7 +-
 ...dependent_backflow_ao_derivatives_pyscf.py |  10 +-
 .../test_slaterjastrow_backflow.py            | 176 +++---------------
 8 files changed, 58 insertions(+), 165 deletions(-)
 create mode 100644 notebooks/test.ipynb

diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 713e5956..d3a7dbd3 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -214,11 +214,11 @@ 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)
@@ -304,6 +304,8 @@ def _process_position(self, pos):
                 # electrons and orbitals
                 xyz = xyz.repeat_interleave(self.nctr_per_ao, dim=2)
                 r = r.repeat_interleave(self.nctr_per_ao, dim=2)
+
+            return (xyz, r)
         else:
 
             # get the elec-atom vectrors/distances
diff --git a/qmctorch/wavefunction/slater_jastrow_unified.py b/qmctorch/wavefunction/slater_jastrow_unified.py
index 8c07a261..cc245f68 100644
--- a/qmctorch/wavefunction/slater_jastrow_unified.py
+++ b/qmctorch/wavefunction/slater_jastrow_unified.py
@@ -240,6 +240,7 @@ def forward(self, x, ao=None):
 
     def ao2mo(self, ao):
         """transforms AO values in to MO values."""
+        print('2', ao.shape)
         return self.mo(self.mo_scf(ao))
 
     def pos2mo(self, x, derivative=0, sum_grad=True):
@@ -281,6 +282,7 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         """
 
         ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
+        print('1', ao.shape)
         mo = self.ao2mo(ao)
         bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
 
@@ -331,6 +333,7 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
 
         # compute the gradient operator matrix
         grad_ao = self.ao(x, derivative=1, sum_grad=False)
+        print(grad_ao.shape)
 
         # compute the derivatives of the MOs
         dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index fa3af66a..4334c918 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -91,7 +91,7 @@ def test_backflow_derivative(self):
 
         # compute der of the backflow pos wrt the
         # original pos
-        dq = self.backflow_trans(self.pos, derivative=1)
+        dq = self.backflow_trans(self.pos, derivative=1).squeeze()
 
         # compute der of the backflow pos wrt the
         # original pos using autograd
@@ -116,7 +116,7 @@ def test_backflow_second_derivative(self):
 
         # compute der of the backflow pos wrt the
         # original pos
-        d2q = self.backflow_trans(self.pos, derivative=2)
+        d2q = self.backflow_trans(self.pos, derivative=2).squeeze()
 
         # compute der of the backflow pos wrt the
         # original pos using autograd
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 9ca1c4f8..eb5d1d03 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
@@ -2,10 +2,10 @@
 
 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
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -74,8 +74,8 @@ def setUp(self):
                             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:
@@ -93,6 +93,7 @@ def test_backflow_derivative(self):
         # 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)
@@ -113,8 +114,8 @@ def test_backflow_derivative(self):
         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 = 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))
@@ -146,8 +147,8 @@ def test_backflow_second_derivative(self):
         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 = d2q.sum([1, 3])
+        d2q = d2q.permute(0, 3, 2, 1)
         d2q_auto = d2q_auto.reshape(
             self.npts, nao,  self.mol.nelec, 3)
 
diff --git a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
index 0299b02f..c4a19bc5 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -7,6 +7,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
 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
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -74,9 +75,11 @@ def setUp(self):
                             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
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 65cedb85..d2351fd3 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
@@ -6,7 +6,8 @@
 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
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -75,8 +76,11 @@ def setUp(self):
                             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:
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 0fef056c..6a709a90 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -1,45 +1,25 @@
-
-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
 
-torch.set_default_tensor_type(torch.DoubleTensor)
-
+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]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.utils import set_torch_double_precision
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrowBackFlow(unittest.TestCase):
+class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -56,13 +36,20 @@ def setUp(self):
             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)
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(
+            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
@@ -72,119 +59,12 @@ def setUp(self):
             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()
-    # t = TestSlaterJastrowBackFlow()
-    # t.setUp()
+    # unittest.main()
+    t = TestSlaterJastrowBackFlow()
+    t.setUp()
     # t.test_antisymmetry()
     # t.test_hess_mo()
     # t.test_grad_mo()
-    # t.test_kinetic_energy()
+    t.test_kinetic_energy()

From 0509b0a4c01ac9c0363f15336056ea065d110e68 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 17 Aug 2021 21:27:57 +0200
Subject: [PATCH 037/286] fix kinetic calcilation

---
 notebooks/test.ipynb                          | 402 ++++++++++++++++++
 .../wavefunction/slater_jastrow_unified.py    |   8 +-
 tests/wavefunction/base_test_cases.py         |   5 +-
 .../test_slaterjastrow_backflow.py            |   8 +-
 ...laterjastrow_orbital_dependent_backflow.py | 168 ++------
 5 files changed, 439 insertions(+), 152 deletions(-)

diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index e69de29b..0501ba29 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -0,0 +1,402 @@
+{
+ "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_unified import SlaterJastrowUnified as 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": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ]
+}
\ No newline at end of file
diff --git a/qmctorch/wavefunction/slater_jastrow_unified.py b/qmctorch/wavefunction/slater_jastrow_unified.py
index cc245f68..36a82d42 100644
--- a/qmctorch/wavefunction/slater_jastrow_unified.py
+++ b/qmctorch/wavefunction/slater_jastrow_unified.py
@@ -189,7 +189,10 @@ def init_kinetic(self, kinetic, backflow):
         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, ao=None):
@@ -240,7 +243,7 @@ def forward(self, x, ao=None):
 
     def ao2mo(self, ao):
         """transforms AO values in to MO values."""
-        print('2', ao.shape)
+
         return self.mo(self.mo_scf(ao))
 
     def pos2mo(self, x, derivative=0, sum_grad=True):
@@ -282,7 +285,7 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         """
 
         ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
-        print('1', ao.shape)
+
         mo = self.ao2mo(ao)
         bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
 
@@ -333,7 +336,6 @@ def gradients_jacobi(self, x, sum_grad=False, pdf=False):
 
         # compute the gradient operator matrix
         grad_ao = self.ao(x, derivative=1, sum_grad=False)
-        print(grad_ao.shape)
 
         # compute the derivatives of the MOs
         dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index 4b63d7d2..bfa699bb 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -203,5 +203,8 @@ def test_hess_mo(self):
             d2val_grad = d2val_grad.T
             assert(torch.allclose(d2val, d2val_grad))
 
-        def test_grad_wf(self):
+        def test_gradients_wf(self):
+            pass
+
+        def test_gradients_pdf(self):
             pass
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 6a709a90..451c40f8 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -61,10 +61,10 @@ def setUp(self):
 
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestSlaterJastrowBackFlow()
-    t.setUp()
+    unittest.main()
+    # t = TestSlaterJastrowBackFlow()
+    # t.setUp()
     # t.test_antisymmetry()
     # t.test_hess_mo()
     # t.test_grad_mo()
-    t.test_kinetic_energy()
+    # t.test_kinetic_energy()
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 3b95a5da..292e0dcf 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -1,46 +1,27 @@
 
-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
 
-torch.set_default_tensor_type(torch.DoubleTensor)
-
+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]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.utils import set_torch_double_precision
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
+class TestSlaterJastrowOrbitalDependentBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -57,14 +38,20 @@ def setUp(self):
             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
-                                        )
+        # 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:
@@ -78,113 +65,6 @@ def setUp(self):
             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()

From 43f2aad1dbba83ab76df7cfa9fed10092e262252 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 17 Aug 2021 21:46:12 +0200
Subject: [PATCH 038/286] compare backflow

---
 .../test_compare_slaterjastrow_backflow.py    |  77 +++----
 ...laterjastrow_orbital_dependent_backflow.py |  77 +++----
 .../test_slatercombinedjastrow_backflow.py    | 196 ++++--------------
 ...laterjastrow_orbital_dependent_backflow.py |   2 +-
 4 files changed, 106 insertions(+), 246 deletions(-)

diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index f2115b95..9522ff64 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -1,39 +1,19 @@
-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
 
-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)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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]
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.utils import set_torch_double_precision
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
@@ -53,19 +33,29 @@ def setUp(self):
             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)
+        # 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.
 
         self.wf_ref = SlaterJastrow(mol,
                                     kinetic='jacobi',
                                     include_all_mo=True,
-                                    configs='single_double(2,2)')
+                                    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
@@ -100,9 +90,6 @@ def test_hess_mo(self):
         d2val_ref = self.wf_ref.ao2mo(d2ao_ref)
         assert(torch.allclose(d2val_ref, d2val.sum(0)))
 
-    def test_grad_wf(self):
-        pass
-
     def test_local_energy(self):
 
         self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
@@ -124,10 +111,10 @@ def test_kinetic_energy(self):
 
 
 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 2e8109d3..955b3569 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -1,39 +1,19 @@
-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
 
-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)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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]
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        hess[:, idim] = tmp[:, idim]
+from qmctorch.utils import set_torch_double_precision
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestCompareSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
@@ -53,12 +33,20 @@ def setUp(self):
             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)
+        # 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
@@ -66,7 +54,9 @@ def setUp(self):
         self.wf_ref = SlaterJastrow(mol,
                                     kinetic='jacobi',
                                     include_all_mo=True,
-                                    configs='single_double(2,2)')
+                                    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
@@ -101,9 +91,6 @@ def test_hess_mo(self):
         d2val_ref = self.wf_ref.ao2mo(d2ao_ref)
         assert(torch.allclose(d2val_ref, d2val.sum(0)))
 
-    def test_grad_wf(self):
-        pass
-
     def test_local_energy(self):
 
         self.wf.kinetic_energy = self.wf.kinetic_energy_jacobi
@@ -125,10 +112,10 @@ def test_kinetic_energy(self):
 
 
 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_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 325131ae..52d688b6 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -1,45 +1,27 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterCombinedJastrowBackflow
-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
 
-torch.set_default_tensor_type(torch.DoubleTensor)
-
+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]
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 
-    # compute the diagonal element of the Hessian
-    z = Variable(torch.ones(jacob.shape[0]))
-    hess = torch.zeros(jacob.shape)
+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
 
-    for idim in range(jacob.shape[1]):
+from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from qmctorch.utils import set_torch_double_precision
 
-        hess[:, idim] = tmp[:, idim]
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterCombinedJastrowBackflow(unittest.TestCase):
+class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
 
     def setUp(self):
 
@@ -50,144 +32,48 @@ def setUp(self):
 
         # molecule
         mol = Molecule(
-            atom='Li 0 0 0; H 0 0 3.14',
+            atom='Li 0 0 0; H 0 0 3.015',
             unit='bohr',
             calculator='pyscf',
             basis='sto-3g',
             redo_scf=True)
 
-        self.wf = SlaterCombinedJastrowBackflow(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': {}})
+        # define jastrow factor
+        jastrow = JastrowFactorCombinedTerms(mol,
+                                             jastrow_kernel={
+                                                 'ee': PadeJastrowKernelElecElec,
+                                                 'en': PadeJastrowKernelElecNuc,
+                                                 'een': BoysHandyJastrowKernel},
+                                             jastrow_kernel_kwargs={
+                                                 'ee': {'w': 1.},
+                                                 'en': {'w': 1.},
+                                                 '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.nbatch = 5
         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)
-
 
 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_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 292e0dcf..bf38b530 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -40,7 +40,7 @@ def setUp(self):
 
         # define jastrow factor
         jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel,)
+            mol, PadeJastrowKernel)
 
         # define backflow trans
         backflow = BackFlowTransformation(

From 33e76fb4a0f42a35df3032c578127d9f0fe1983e Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 10:01:12 +0200
Subject: [PATCH 039/286] fix test hvd

---
 notebooks/test.ipynb     | 37 +++++++++++++++++++++++++++++++++++++
 tests_hvd/test_h2_hvd.py | 10 +++++++++-
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index 0501ba29..165a2b45 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -391,6 +391,43 @@
     "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,
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index ccd2eb1d..ef63ddb3 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 SolverSlaterJastrowHorovod
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
 
 
@@ -36,9 +39,14 @@ def setUp(self):
             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

From 56f267efd7ca1aceb3401249d4b46c2a3b0ec7b2 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 15:28:23 +0200
Subject: [PATCH 040/286] fix sampler test

---
 tests/sampler/test_sampler_base.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index 7e928164..62325546 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -5,7 +5,10 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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):
@@ -24,5 +27,8 @@ def setUp(self):
             calculator='pyscf',
             basis='sto-3g')
 
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
+
         # orbital
-        self.wf = SlaterJastrow(self.mol)
+        self.wf = SlaterJastrow(self.mol, jastrow=jastrow)

From 59a4e758e70fb11ec09617018c6c8b36334fc0f8 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 15:29:55 +0200
Subject: [PATCH 041/286] fix scf

---
 tests/scf/test_gto2sto_fit.py            | 10 ++++++++--
 tests/wavefunction/test_slaterjastrow.py |  6 ------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/scf/test_gto2sto_fit.py b/tests/scf/test_gto2sto_fit.py
index 8aea1c78..684ec559 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -5,7 +5,10 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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):
@@ -25,8 +28,11 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
+
         self.wf = SlaterJastrow(mol, kinetic='auto',
-                                configs='ground_state').gto2sto()
+                                configs='ground_state', jastrow=jastrow).gto2sto()
 
         self.pos = -0.25 + 0.5 * \
             torch.as_tensor(np.random.rand(10, 18))
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index c6407fd8..f1d89aab 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -12,8 +12,6 @@
 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
 
@@ -42,10 +40,6 @@ def setUp(self):
         jastrow = JastrowFactorElectronElectron(
             mol, PadeJastrowKernel)
 
-        # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
-
         self.wf = SlaterJastrow(mol,
                                 kinetic='auto',
                                 include_all_mo=False,

From a1d8f6ac2396e8b9a75d5fea0cfdcfcaba34592e Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 15:36:21 +0200
Subject: [PATCH 042/286] fix test utils

---
 tests/utils/test_interpolate.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 60004c2c..60bb16db 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -5,7 +5,10 @@
 from qmctorch.utils import (InterpolateAtomicOrbitals,
                             InterpolateMolecularOrbitals)
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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):
@@ -19,9 +22,12 @@ def setUp(self):
             calculator='pyscf',
             basis='dzp')
 
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
+
         # wave function
         self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)')
+                                configs='single(2,2)', jastrow=jastrow)
 
         npts = 51
         self.pos = torch.zeros(npts, 6)

From ab9a6cbd10bdb5e9254f45d3a946df6174440a6b Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 16:11:21 +0200
Subject: [PATCH 043/286] fix jastrow test

---
 .../elec_elec/base_elec_elec_jastrow_test.py  | 116 ++++++++++++++++++
 .../elec_elec/test_generic_jastrow.py         |  87 ++-----------
 .../jastrows/elec_elec/test_pade_jastrow.py   | 112 ++---------------
 .../elec_elec/test_pade_jastrow_polynom.py    |  78 ++----------
 .../elec_elec/test_scaled_pade_jastrow.py     |  64 ++--------
 .../test_scaled_pade_jastrow_polynom.py       |  81 ++----------
 6 files changed, 164 insertions(+), 374 deletions(-)
 create mode 100644 tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py

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..745bb179
--- /dev/null
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -0,0 +1,116 @@
+import unittest
+from torch.autograd import grad, gradcheck, Variable
+
+import numpy as np
+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"""
+            self.jastrow = None
+            self.nbatch = None
+            self.pos = None
+
+        def test_jastrow(self):
+            """simply checks that the values are not crashing."""
+            val = 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/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index 30bc2968..928b9461 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -1,105 +1,36 @@
-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
 
 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 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
+        mol = SimpleNamespace(nup=4, ndown=4)
+        self.nelec = mol.nup + mol.ndown
+
         self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
+            mol,
             FullyConnectedJastrowKernel)
         self.nbatch = 5
 
         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 ed894195..687eef0f 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -1,49 +1,28 @@
 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
 
 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 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,
+            mol,
             PadeJastrowKernel,
             kernel_kwargs={'w': 0.1})
         self.nbatch = 5
@@ -51,81 +30,6 @@ def setUp(self):
         self.pos = 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_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()))
-
 
 if __name__ == "__main__":
     unittest.main()
-    t = TestPadeJastrow()
-    t.setUp()
-    t.test_permutation()
-    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 d3589cef..696bd0c2 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -1,49 +1,31 @@
-import torch
-from torch.autograd import Variable, grad, gradcheck
+
 import unittest
 import numpy as np
+import torch
 
-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
-
-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]):
+from base_elec_elec_jastrow_test import BaseTestJastrow
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from types import SimpleNamespace
 
-        hess[:, idim] = tmp[:, idim]
+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
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-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,
+            mol, PadeJastrowPolynomialKernel,
             kernel_kwargs={'order': 5,
                            'weight_a': 0.1*torch.ones(5),
                            'weight_b': 0.1*torch.ones(5)})
@@ -52,42 +34,6 @@ def setUp(self):
         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 80a88f49..07e8c766 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -1,50 +1,28 @@
 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
 
 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 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,
+            mol,
             PadeJastrowKernel,
             kernel_kwargs={'w': 0.1},
             scale=True)
@@ -53,32 +31,6 @@ def setUp(self):
         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 c43a1132..a20d234f 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,99 +1,40 @@
-import unittest
 
+import unittest
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
-
-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
-
-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]):
+from base_elec_elec_jastrow_test import BaseTestJastrow
 
-        tmp = grad(jacob[:, idim], pos,
-                   grad_outputs=z,
-                   only_inputs=True,
-                   create_graph=True)[0]
+from types import SimpleNamespace
 
-        hess[:, idim] = tmp[:, idim]
+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
 
-    return hess
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-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,
+            mol, PadeJastrowPolynomialKernel,
             kernel_kwargs={'order': 5,
                            'weight_a': 0.1*torch.ones(5),
                            'weight_b': 0.1*torch.ones(5)},
             scale=True)
-
-        self.nbatch = 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_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()

From 388289dcb5deed54019aa151914234e706a6e8d4 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 16:11:53 +0200
Subject: [PATCH 044/286] remove test jastrow orbital dependent

---
 .../test_slater_orbital_dependent_jastrow.py  | 225 ------------------
 1 file changed, 225 deletions(-)
 delete mode 100644 tests/wavefunction/test_slater_orbital_dependent_jastrow.py

diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
deleted file mode 100644
index da636f4a..00000000
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ /dev/null
@@ -1,225 +0,0 @@
-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, btrace
-
-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):
-
-    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.015',
-            unit='bohr',
-            calculator='pyscf',
-            basis='sto-3g',
-            redo_scf=True)
-
-        self.wf = SlaterOrbitalDependentJastrow(
-            mol,
-            kinetic='auto',
-            jastrow_kernel=FullyConnectedJastrowKernel,
-            configs='single_double(2,4)',
-            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.nbatch = 3
-        self.pos = torch.as_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]
-
-        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_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)
-
-    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)
-
-
-if __name__ == "__main__":
-    unittest.main()

From 2bbbdca524405f9cb6bdcb924efbcfa6d04416f7 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 18:39:56 +0200
Subject: [PATCH 045/286] init file in test folders

---
 tests/utils/__init__.py                       |   0
 tests/wavefunction/jastrows/__init__.py       |   0
 .../jastrows/distance/__init__.py             |   0
 .../jastrows/elec_elec/__init__.py            |   0
 .../jastrows/elec_elec_nuc/__init__.py        |   0
 .../jastrows/elec_nuc/__init__.py             |   0
 tests/wavefunction/jastrows/graph/__init__.py |   0
 .../orbitals/backflow/__init__.py             |   0
 tests/wavefunction/orbitals/base_test_ao.py   | 119 +++++++++++++++
 .../orbitals/test_ao_derivatives_adf.py       | 128 ++--------------
 .../orbitals/test_ao_derivatives_pyscf.py     | 140 ++----------------
 .../orbitals/test_ao_values_adf.py            |   7 +-
 .../orbitals/test_ao_values_pyscf.py          |   8 +-
 .../orbitals/test_cartesian_harmonics_adf.py  |  28 ++--
 .../orbitals/test_mo_values_adf.py            |   2 +-
 .../wavefunction/orbitals/test_radial_gto.py  |  54 ++++---
 .../wavefunction/orbitals/test_radial_sto.py  |  54 ++++---
 tests/wavefunction/pooling/__init__.py        |   0
 .../test_slatercombinedjastrow.py             |   2 +-
 .../test_slatercombinedjastrow_backflow.py    |   2 +-
 tests/wavefunction/test_slaterjastrow.py      |   2 +-
 .../test_slaterjastrow_backflow.py            |   2 +-
 tests/wavefunction/test_slaterjastrow_cas.py  |   2 +-
 .../test_slaterjastrow_generic.py             |   2 +-
 ...laterjastrow_orbital_dependent_backflow.py |   2 +-
 .../test_slaterjastrow_unified.py             |   2 +-
 26 files changed, 227 insertions(+), 329 deletions(-)
 create mode 100644 tests/utils/__init__.py
 create mode 100644 tests/wavefunction/jastrows/__init__.py
 create mode 100644 tests/wavefunction/jastrows/distance/__init__.py
 create mode 100644 tests/wavefunction/jastrows/elec_elec/__init__.py
 create mode 100644 tests/wavefunction/jastrows/elec_elec_nuc/__init__.py
 create mode 100644 tests/wavefunction/jastrows/elec_nuc/__init__.py
 create mode 100644 tests/wavefunction/jastrows/graph/__init__.py
 create mode 100644 tests/wavefunction/orbitals/backflow/__init__.py
 create mode 100644 tests/wavefunction/orbitals/base_test_ao.py
 create mode 100644 tests/wavefunction/pooling/__init__.py

diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
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/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_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_nuc/__init__.py b/tests/wavefunction/jastrows/elec_nuc/__init__.py
new file mode 100644
index 00000000..e69de29b
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/orbitals/backflow/__init__.py b/tests/wavefunction/orbitals/backflow/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
new file mode 100644
index 00000000..dd06a9fc
--- /dev/null
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -0,0 +1,119 @@
+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):
+            self.ao = None
+            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):
+
+            ao = 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):
+
+            ao = 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/test_ao_derivatives_adf.py b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
index 070a71c3..6038d514 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -1,81 +1,20 @@
-
+from ...path_utils import PATH_TEST
 import unittest
+import numpy as np
 import torch
 
-from torch.autograd import Variable, grad, gradcheck
+from .base_test_ao import BaseTestAO
 
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from ...path_utils import PATH_TEST
+from torch.autograd import Variable
 
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 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
-
-
-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
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestAOderivativesADF(unittest.TestCase):
+class TestAOderivativesADF(BaseTestAO.BaseTestAOderivatives):
 
     def setUp(self):
 
@@ -84,7 +23,7 @@ def setUp(self):
         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
@@ -92,49 +31,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 7606b746..b4f06eb8 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
@@ -1,80 +1,17 @@
 import unittest
 import numpy as np
 import torch
-from pyscf import gto
-from torch.autograd import Variable, grad, gradcheck
 
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-
-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
-
-
-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]
+from .base_test_ao import BaseTestAO
 
-        hess[:, k] = tmp[:, iy+1]
-        k = k + 1
+from torch.autograd import Variable
 
-    return hess
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestAOderivativesPyscf(unittest.TestCase):
+class TestAOderivativesPyscf(BaseTestAO.BaseTestAOderivatives):
 
     def setUp(self):
 
@@ -89,10 +26,8 @@ def setUp(self):
                             basis=basis,
                             unit='bohr')
 
-        self.m = gto.M(atom=at, 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
@@ -100,64 +35,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..7537109d 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
 
@@ -81,7 +82,7 @@ def setUp(self):
         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
@@ -94,7 +95,7 @@ def setUp(self):
 
     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):
 
diff --git a/tests/wavefunction/orbitals/test_ao_values_pyscf.py b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
index cc941a56..8215619d 100644
--- a/tests/wavefunction/orbitals/test_ao_values_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
@@ -7,7 +7,7 @@
 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
 
@@ -27,7 +27,7 @@ def setUp(self):
         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)
 
@@ -44,7 +44,7 @@ def test_ao(self):
 
         nzlm = np.linalg.norm(self.m.cart2sph_coeff(), axis=1)
 
-        aovals = self.wf.ao(self.pos).detach().numpy()/nzlm
+        aovals = self.ao(self.pos).detach().numpy()/nzlm
         aovals_ref = self.m.eval_ao('GTOval_cart',
                                     self.pos.detach().numpy()[:, :3])
 
@@ -63,7 +63,7 @@ def test_ao_deriv(self):
 
         nzlm = np.linalg.norm(self.m.cart2sph_coeff(), axis=1)
 
-        daovals = self.wf.ao(
+        daovals = self.ao(
             self.pos, derivative=1).detach().numpy()/nzlm
 
         daovals_ref = self.m.eval_gto(
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
index e58463d1..0280b0d1 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -4,7 +4,7 @@
 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
@@ -22,9 +22,7 @@ def setUp(self):
         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):
 
@@ -33,8 +31,8 @@ def test_first_derivative_x(self):
         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, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(
             xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
@@ -60,8 +58,8 @@ def test_first_derivative_y(self):
         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, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(
             xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
@@ -88,8 +86,8 @@ def test_first_derivative_z(self):
         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, r = self.ao._process_position(self.pos)
+        R, dR = self.ao.harmonics(
             xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
@@ -132,8 +130,8 @@ 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, r = self.ao._process_position(self.pos)
+        R, dR, d2R = self.ao.harmonics(
             xyz, derivative=[0, 1, 2], sum_grad=False)
 
         for iorb in range(7):
@@ -173,11 +171,11 @@ 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, r = self.ao._process_position(self.pos)
+        d2R_sum = self.ao.harmonics(
             xyz, derivative=2, sum_hess=True)
 
-        d2R = self.wf.ao.harmonics(
+        d2R = self.ao.harmonics(
             xyz, derivative=2, sum_hess=False)
 
         assert(torch.allclose(d2R.sum(-1), d2R_sum))
diff --git a/tests/wavefunction/orbitals/test_mo_values_adf.py b/tests/wavefunction/orbitals/test_mo_values_adf.py
index 5bb06c14..3a16cc09 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_unified import SlaterJastrowUnified as SlaterJastrow
 
 from ...path_utils import PATH_TEST
 
diff --git a/tests/wavefunction/orbitals/test_radial_gto.py b/tests/wavefunction/orbitals/test_radial_gto.py
index 680f08f9..b7e90ebe 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -5,7 +5,7 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction import SlaterJastrow
-
+from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
 from .second_derivative import second_derivative
 
 
@@ -22,9 +22,7 @@ def setUp(self):
                             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):
 
@@ -33,12 +31,12 @@ def test_first_derivative_x(self):
         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()
@@ -64,12 +62,12 @@ def test_first_derivative_y(self):
         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()
@@ -95,12 +93,12 @@ def test_first_derivative_z(self):
         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
@@ -140,12 +138,12 @@ 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, dR, 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):
 
diff --git a/tests/wavefunction/orbitals/test_radial_sto.py b/tests/wavefunction/orbitals/test_radial_sto.py
index 8aacaa00..9883c120 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -4,7 +4,7 @@
 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
 
@@ -23,9 +23,7 @@ def setUp(self):
         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):
 
@@ -34,12 +32,12 @@ def test_first_derivative_x(self):
         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()
@@ -65,12 +63,12 @@ def test_first_derivative_y(self):
         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()
@@ -96,12 +94,12 @@ def test_first_derivative_z(self):
         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
@@ -142,12 +140,12 @@ 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, dR, 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):
 
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/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 8ddd8a5b..65ae5f54 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -2,7 +2,7 @@
 import numpy as np
 import torch
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 52d688b6..d515743e 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -2,7 +2,7 @@
 import torch
 import unittest
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index f1d89aab..d809ef23 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -4,7 +4,7 @@
 import torch
 
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 451c40f8..d6f40638 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -2,7 +2,7 @@
 import torch
 import unittest
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index b2a9e54a..3e5d6e4a 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -4,7 +4,7 @@
 from numpy.lib.stride_tricks import _broadcast_arrays_dispatcher
 import torch
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 6b08b282..90dd1ff0 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -2,7 +2,7 @@
 import numpy as np
 import torch
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 
 from qmctorch.scf import Molecule
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index bf38b530..f46cffdd 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -4,7 +4,7 @@
 import torch
 import unittest
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
diff --git a/tests/wavefunction/test_slaterjastrow_unified.py b/tests/wavefunction/test_slaterjastrow_unified.py
index 7e08102a..d6fd01a7 100644
--- a/tests/wavefunction/test_slaterjastrow_unified.py
+++ b/tests/wavefunction/test_slaterjastrow_unified.py
@@ -2,7 +2,7 @@
 import numpy as np
 import torch
 
-from base_test_cases import BaseTestCases
+from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow

From 60f8e7e4fb0acca112a2c85a8ec435ed80dc2b35 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 18 Aug 2021 21:53:42 +0200
Subject: [PATCH 046/286] fix jastrow tst

---
 .../jastrows/elec_elec/test_generic_jastrow.py            | 2 +-
 .../wavefunction/jastrows/elec_elec/test_pade_jastrow.py  | 2 +-
 .../jastrows/elec_elec/test_pade_jastrow_polynom.py       | 2 +-
 .../jastrows/elec_elec/test_scaled_pade_jastrow.py        | 2 +-
 .../elec_elec/test_scaled_pade_jastrow_polynom.py         | 2 +-
 .../elec_elec_nuc/test_three_body_jastrow_boys_handy.py   | 8 +++++---
 .../test_three_body_jastrow_fully_connected.py            | 6 ++++--
 .../elec_nuc/test_electron_nuclei_fully_connected.py      | 6 ++++--
 .../elec_nuc/test_electron_nuclei_pade_jastrow.py         | 6 ++++--
 9 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index 928b9461..ef8fa1cc 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -4,7 +4,7 @@
 import torch
 
 
-from base_elec_elec_jastrow_test import BaseTestJastrow
+from .base_elec_elec_jastrow_test import BaseTestJastrow
 
 from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 687eef0f..7bb0a1da 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -2,7 +2,7 @@
 import numpy as np
 import torch
 
-from base_elec_elec_jastrow_test import BaseTestJastrow
+from .base_elec_elec_jastrow_test import BaseTestJastrow
 
 from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
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 696bd0c2..13a33a17 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -4,7 +4,7 @@
 import torch
 
 
-from base_elec_elec_jastrow_test import BaseTestJastrow
+from .base_elec_elec_jastrow_test import BaseTestJastrow
 
 from types import SimpleNamespace
 
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 07e8c766..4d7bdbcf 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -2,7 +2,7 @@
 import numpy as np
 import torch
 
-from base_elec_elec_jastrow_test import BaseTestJastrow
+from .base_elec_elec_jastrow_test import BaseTestJastrow
 
 from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
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 a20d234f..626d7535 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
@@ -4,7 +4,7 @@
 import torch
 
 
-from base_elec_elec_jastrow_test import BaseTestJastrow
+from .base_elec_elec_jastrow_test import BaseTestJastrow
 
 from types import SimpleNamespace
 
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 b2d31fef..d7c3f2c1 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, gradcheck
@@ -43,9 +43,11 @@ def setUp(self):
         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)
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 33d40ce4..1227ba48 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, gradcheck
@@ -44,8 +44,10 @@ def setUp(self):
         self.nelec = self.nup + self.ndown
         self.natom = 4
         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)
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 1fa7699e..f019dcbc 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
@@ -43,8 +43,10 @@ def setUp(self):
         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)
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 bb4aae7d..832beb5d 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,5 +1,5 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
@@ -44,8 +44,10 @@ def setUp(self):
         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, PadeJastrowKernel)
+            self.mol, PadeJastrowKernel)
         self.nbatch = 5
 
         self.pos = torch.rand(self.nbatch, self.nelec * 3)

From 0f5d859b020cb49f4d730ed5673152e405bc66e0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 09:12:52 +0200
Subject: [PATCH 047/286] bypass hvd test for now

---
 .github/workflows/build.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ad03a614..7461a55a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -33,10 +33,10 @@ jobs:
       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:

From ed3a70deabff322043d9577842f60fe8b7bf32f0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 09:44:28 +0200
Subject: [PATCH 048/286] remove tables mendeleev

---
 tests/wavefunction/test_slaterjastrow_cas.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index 3e5d6e4a..de6dcb25 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -1,7 +1,5 @@
 import unittest
-from mendeleev.tables import Base
 import numpy as np
-from numpy.lib.stride_tricks import _broadcast_arrays_dispatcher
 import torch
 
 from .base_test_cases import BaseTestCases

From e87be8969f8e84ff4def78e124765791fd6c19d5 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 10:37:08 +0200
Subject: [PATCH 049/286] init of the elec-elec jastrpw

---
 qmctorch/wavefunction/jastrows/elec_elec/__init__.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index e69de29b..3c165029 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -0,0 +1,4 @@
+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

From 458513c994c21f710b83a6e81e0d55f019c4ba38 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 11:57:24 +0200
Subject: [PATCH 050/286] refactor test solver

---
 .../orbitals/backflow/__init__.py             |   7 +
 .../slater_orbital_dependent_jastrow.py       | 358 ------------------
 tests/solver/test_base_solver.py              |  46 +++
 tests/solver/test_h2.py                       | 178 ---------
 tests/solver/test_h2_adf.py                   |  64 +---
 tests/solver/test_h2_adf_jacobi.py            |  46 +--
 tests/solver/test_h2_correlated.py            | 142 -------
 tests/solver/test_h2_pyscf_geo_opt.py         | 102 +++++
 tests/solver/test_h2_pyscf_hamiltonian.py     |  70 ++++
 tests/solver/test_h2_pyscf_jacobi.py          |  70 ++++
 tests/solver/test_h2_pyscf_metropolis.py      | 112 ++++++
 ...est_h2_stats.py => test_h2_pyscf_stats.py} |  18 +-
 tests/solver/test_lih_adf_backflow.py         |  56 +--
 tests/solver/test_lih_correlated.py           | 104 -----
 .../solver/{test_lih.py => test_lih_pyscf.py} |  43 +--
 tests/solver/test_lih_pyscf_backflow.py       |  60 ++-
 .../solver/test_lih_pyscf_compare_backflow.py |  24 +-
 .../solver/test_lih_pyscf_generic_backflow.py |  58 +--
 ...w.py => test_lih_pyscf_generic_jastrow.py} |  45 +--
 ...st_lih_pyscf_orbital_dependent_backflow.py |  60 ++-
 .../test_slaterjastrow_backflow.py            |   8 +-
 21 files changed, 565 insertions(+), 1106 deletions(-)
 delete mode 100644 qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
 create mode 100644 tests/solver/test_base_solver.py
 delete mode 100644 tests/solver/test_h2.py
 delete mode 100644 tests/solver/test_h2_correlated.py
 create mode 100644 tests/solver/test_h2_pyscf_geo_opt.py
 create mode 100644 tests/solver/test_h2_pyscf_hamiltonian.py
 create mode 100644 tests/solver/test_h2_pyscf_jacobi.py
 create mode 100644 tests/solver/test_h2_pyscf_metropolis.py
 rename tests/solver/{test_h2_stats.py => test_h2_pyscf_stats.py} (80%)
 delete mode 100644 tests/solver/test_lih_correlated.py
 rename tests/solver/{test_lih.py => test_lih_pyscf.py} (53%)
 rename tests/solver/{test_lih_generic_jastrow.py => test_lih_pyscf_generic_jastrow.py} (56%)

diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index e69de29b..7fecfefd 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -0,0 +1,7 @@
+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
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
deleted file mode 100644
index d42b042b..00000000
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ /dev/null
@@ -1,358 +0,0 @@
-import torch
-import operator
-
-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
-
-
-class SlaterOrbitalDependentJastrow(SlaterJastrowBase):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
-        """Implementation of the QMC Network.
-
-        Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
-            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
-            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            use_jastrow (bool, optional): turn jastrow factor ON/OFF. Defaults to True.
-            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
-            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
-                                             popualted in the configs. Defaults to False
-        Examples::
-            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-        """
-
-        if jastrow_kernel is None:
-            raise ValueError(
-                'Orbital dependent Jastrow factor requires a valid jastrow kernel.')
-
-        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
-        self.use_jastrow = True
-
-        self.jastrow = JastrowFactorElectronElectron(
-            self.mol.nup, self.mol.ndown, jastrow_kernel,
-            kernel_kwargs=jastrow_kernel_kwargs,
-            orbital_dependent_kernel=True,
-            number_of_orbitals=self.nmo_opt,
-            cuda=self.cuda)
-
-        if self.cuda:
-            self.jastrow = self.jastrow.to(self.device)
-
-        self.jastrow_type = jastrow_kernel.__class__.__name__
-
-        self.log_data()
-
-    def ordered_jastrow(self, pos, derivative=0, sum_grad=True):
-        """Returns the value of the jastrow with the correct dimensions
-
-        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
-                          Nbatch, Nelec, Nmo (sum_grad = True)
-                          Nbatch, Nelec, Nmo, Ndim (sum_grad = False)
-        """
-        jast_vals = self.jastrow(pos, derivative, sum_grad)
-
-        def permute(vals):
-            """transpose the data depending on the number of dim."""
-            if vals.ndim == 3:
-                return vals.permute(1, 2, 0)
-            elif vals.ndim == 4:
-                return vals.permute(1, 3, 0, 2)
-
-        if isinstance(jast_vals, tuple):
-            return tuple([permute(v) for v in jast_vals])
-        else:
-            return permute(jast_vals)
-
-    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)
-        """
-
-        # compute the jastrow from the pos
-        J = self.ordered_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)
-
-        # jastrow for each orbital
-        x = J * x
-
-        # pool the mos
-        x = self.pool(x)
-
-        # compute the CI and return
-        return self.fc(x)
-
-    def ao2mo(self, ao):
-        return self.mo(self.mo_scf(ao))
-
-    def ao2cmo(self, ao, jastrow):
-        return jastrow * self.mo(self.mo_scf(ao))
-
-    def pos2mo(self, x, derivative=0, sum_grad=True):
-        """Compute the uncorrelated MOs from the positions."""
-
-        ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
-        if sum_grad:
-            return self.ao2mo(ao)
-        else:
-            return self.ao2mo(ao.transpose(2, 3)).transpose(2, 3)
-
-    def pos2cmo(self, x, derivative=0, sum_grad=True):
-        """Get the values of correlated MOs
-
-        Arguments:
-            x {torch.tensor} -- positions of the electrons [nbatch, nelec*ndim]
-
-
-        Returns:
-            torch.tensor -- MO matrix [nbatch, nelec, nmo]
-        """
-        if derivative == 0:
-            mo = self.pos2mo(x)
-            jast = self.ordered_jastrow(x)
-            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)
-
-            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
-
-        elif derivative == 2:
-
-            # atomic orbital
-            ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
-
-            # bare molecular orbitals
-            mo = self.ao2mo(ao)
-            dmo = self.ao2mo(dao.transpose(2, 3)).transpose(2, 3)
-            d2mo = self.ao2mo(d2ao)
-
-            # jastrows
-            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)
-            d2jast_mo = d2jast.sum(1).unsqueeze(1) * mo
-
-            # assemble kin op
-            return jast_d2mo + 2 * djast_dmo + d2jast_mo
-
-    def kinetic_energy_jacobi(self, x,  **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
-        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
-        """
-
-        # get the matrix of correlated orbitals for all elec
-        cmo = self.pos2cmo(x)
-
-        # compute the value of the slater det
-        slater_dets = self.pool(cmo)
-
-        # compute  \Delta A (A = matrix of the correlated MO)
-        bhess = self.pos2cmo(x, 2)
-
-        # compute ( tr(A_u^-1\Delta A_u) + tr(A_d^-1\Delta A_d) )
-        hess = self.pool.operator(cmo, bhess)
-
-        # compute \grad A
-        bgrad = self.get_gradient_operator(x)
-
-        # compute (tr(A_u^-1\nabla A_u) * tr(A_d^-1\nabla A_d))
-        grad = self.pool.operator(cmo, bgrad, op=None)
-        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))
-
-        # assemble
-        return self.fc(kin * slater_dets) / self.fc(slater_dets)
-
-    def gradients_jacobi(self, x, sum_grad=True, pdf=False):
-        """Computes the gradients of the wf using Jacobi's Formula
-
-        Args:
-            x ([type]): [description]
-        """
-
-        if pdf:
-            raise NotImplementedError(
-                'Gradients of the pdf not implemented for ', self.__name__)
-
-        # get the CMO matrix
-        cmo = self.pos2cmo(x)
-
-        # get the grad of the wf
-        if sum_grad:
-            # bgrad = self.pos2cmo(x, derivative=1)
-            bgrad = self.get_gradient_operator(x).sum(0)
-        else:
-            bgrad = self.get_gradient_operator(x)
-
-        # compute the value of the grad using trace trick
-        grad = self.pool.operator(cmo, bgrad, op=operator.add)
-
-        # compute the total wf
-        psi = self.pool(cmo)
-
-        out = self.fc(grad * psi)
-        out = out.transpose(0, 1)
-
-        # assemble
-        return out
-
-    def get_hessian_operator(self, x):
-        """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
-        """
-        mo = self.pos2mo(x)
-        dmo = self.pos2mo(x, derivative=1, sum_grad=False)
-        d2mo = self.pos2mo(x, derivative=2)
-
-        jast = self.ordered_jastrow(x)
-        djast = self.ordered_jastrow(
-            x, derivative=1, sum_grad=False)
-        d2jast = self.ordered_jastrow(x, derivative=2)
-
-        # \Delta_n J * MO
-        d2jast_mo = d2jast.permute(1, 0, 2).unsqueeze(2) * mo
-
-        # stride d2mo
-        eye = torch.eye(self.nelec).to(self.device)
-        d2mo = d2mo.unsqueeze(2) * eye.unsqueeze(-1)
-
-        # reshape d2mo to nelec, nbatch, nelec, nmo
-        d2mo = d2mo.permute(1, 0, 2, 3)
-
-        # \Delta_n MO * J
-        d2mo_jast = d2mo * jast.repeat(1, self.nelec, 1)
-
-        # reformat to have Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(3, 0, 1, 2)
-
-        # stride
-        eye = torch.eye(self.nelec).to(self.device)
-        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
-
-        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(2, 0, 1, 3, 4)
-
-        # reshape djast to Nelec, Ndim, Nbatch, 1, Nmo
-        djast = djast.permute(1, 3, 0, 2).unsqueeze(-2)
-
-        # \nabla jast \nabla mo
-        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
-
-    def get_gradient_operator(self, x):
-        """Compute the gradient operator
-
-        Args:
-            x ([type]): [description]
-            ao ([type]): [description]
-            dao ([type]): [description]
-        """
-
-        mo = self.pos2mo(x)
-        dmo = self.pos2mo(x, derivative=1, sum_grad=False)
-
-        jast = self.ordered_jastrow(x)
-        djast = self.ordered_jastrow(x, derivative=1, sum_grad=False)
-
-        # reformat to have Nelec, Ndim, Nbatch, 1, Nmo
-        djast = djast.permute(1, 3, 0, 2).unsqueeze(-2)
-
-        # reformat to have Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(3, 0, 1, 2)
-
-        # stride the tensor
-        eye = torch.eye(self.nelec).to(self.device)
-        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
-
-        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(2, 0, 1, 3, 4)
-
-        # assemble the derivative
-        out = (mo * djast + dmo * jast)
-
-        # collapse the first two dimensions
-        out = out.reshape(-1, *(out.shape[2:]))
-        return out
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
new file mode 100644
index 00000000..5fbc592a
--- /dev/null
+++ b/tests/solver/test_base_solver.py
@@ -0,0 +1,46 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+
+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):
+
+            # sample and compute observables
+            obs = self.solver.single_point()
+            e, v = obs.energy, obs.variance
+
+            if self.expected_energy is not None:
+                assert(
+                    np.any(np.isclose(e.data.item(), np.array(self.expected_energy))))
+
+            if self.expected_variance is not None:
+                assert(
+                    np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
+
+        def test2_wf_opt_grad_auto(self):
+
+            self.solver.configure(track=['local_energy', 'parameters'],
+                                  loss='energy', grad='auto')
+            _ = self.solver.run(5)
+
+        def test3_wf_opt_grad_manual(self):
+
+            self.solver.configure(track=['local_energy', 'parameters'],
+                                  loss='energy', grad='manual')
+            _ = self.solver.run(5)
diff --git a/tests/solver/test_h2.py b/tests/solver/test_h2.py
deleted file mode 100644
index 9ee0e2a8..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 SolverSlaterJastrow
-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 = SolverSlaterJastrow(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 9dcb5057..da70ae24 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -1,18 +1,19 @@
+from ..path_utils import PATH_TEST
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.scf import Molecule
+from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.sampler import Metropolis
 import unittest
 
-import numpy as np
+
 import torch
 import torch.optim as optim
 
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
-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):
 
@@ -23,9 +24,13 @@ def setUp(self):
             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)')
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -46,45 +51,12 @@ def setUp(self):
         self.solver = SolverSlaterJastrow(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
-
         # 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 0887a28d..ace842e6 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -7,11 +7,13 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
 from ..path_utils import PATH_TEST
+from .test_base_solver import BaseTestSolvers
 
 
-class TestH2ADFJacobi(unittest.TestCase):
+class TestH2ADFJacobi(BaseTestSolvers.BaseTestSolverMolecule):
 
     def setUp(self):
 
@@ -45,44 +47,12 @@ def setUp(self):
         self.solver = SolverSlaterJastrow(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())
-
         # 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 1e22da4b..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 SolverSlaterJastrow
-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 = SolverSlaterJastrow(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_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
new file mode 100644
index 00000000..60c2aac2
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -0,0 +1,102 @@
+import unittest
+
+import numpy as np
+import torch
+import torch.optim as optim
+
+
+from qmctorch.sampler import Metropolis
+from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.utils import (plot_block, plot_blocking_energy,
+                            plot_correlation_coefficient,
+                            plot_integrated_autocorrelation_time,
+                            plot_walkers_traj)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+
+__PLOT__ = True
+
+
+class TestH2GeoOpt(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')
+
+        # 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 = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
+
+    def test_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
+        gse = -1.16
+        assert(e > 2 * gse and e < 0.)
+        assert(v > 0 and v < 2.)
+
+
+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_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
new file mode 100644
index 00000000..bd52dda4
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -0,0 +1,70 @@
+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 SolverSlaterJastrow
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 = SolverSlaterJastrow(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..25bb7f8d
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -0,0 +1,70 @@
+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 SolverSlaterJastrow
+
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 = SolverSlaterJastrow(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..3b8cac67
--- /dev/null
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -0,0 +1,112 @@
+from qmctorch.wavefunction import jastrows
+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 SolverSlaterJastrow
+from qmctorch.utils import (plot_block, plot_blocking_energy,
+                            plot_correlation_coefficient,
+                            plot_integrated_autocorrelation_time,
+                            plot_walkers_traj)
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 = SolverSlaterJastrow(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]
+
+    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
+        gse = -1.16
+        assert(e > 2 * gse and e < 0.)
+        assert(v > 0 and v < 2.)
+
+
+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_stats.py b/tests/solver/test_h2_pyscf_stats.py
similarity index 80%
rename from tests/solver/test_h2_stats.py
rename to tests/solver/test_h2_pyscf_stats.py
index 74b9f4db..f4cfebb6 100644
--- a/tests/solver/test_h2_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -11,10 +11,8 @@
                             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_unified import SlaterJastrowUnified as SlaterJastrow
 
 
 class TestH2Stat(unittest.TestCase):
@@ -35,9 +33,12 @@ def setUp(self):
             calculator='pyscf',
             basis='sto-3g')
 
+        # jastrow
+        jastrow = JastrowFactor(self.mol, PadeJastrowKernel)
+
         # wave function
         self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)')
+                                configs='single(2,2)', jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -73,10 +74,9 @@ 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_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index a2e50df6..a63b463a 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -7,13 +7,16 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 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_unified import SlaterJastrowUnified as 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):
 
@@ -26,11 +29,19 @@ def setUp(self):
             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)
@@ -64,37 +75,6 @@ def setUp(self):
             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
deleted file mode 100644
index 2d228dba..00000000
--- a/tests/solver/test_lih_correlated.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterOrbitalDependentJastrow
-from qmctorch.utils import set_torch_double_precision
-
-from ..path_utils import PATH_TEST
-
-
-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()
-        self.mol = Molecule(load=path_hdf5)
-
-        # wave function
-        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)
-
-        # jastrow weights
-        for ker in self.wf.jastrow.jastrow_kernel.jastrow_functions:
-            ker.weight.data = torch.rand(1)
-
-        # 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 = SolverSlaterJastrow(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)
-
-        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
-
-    # 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 = TestLiHCorrelated()
-    # t.setUp()
-    # t.test_0_wavefunction()
-    # t.test1_single_point()
-    # t.test2_wf_opt_grad_auto()
-    # t.test3_wf_opt_grad_manual()
diff --git a/tests/solver/test_lih.py b/tests/solver/test_lih_pyscf.py
similarity index 53%
rename from tests/solver/test_lih.py
rename to tests/solver/test_lih_pyscf.py
index 20cfa560..35958e4c 100644
--- a/tests/solver/test_lih.py
+++ b/tests/solver/test_lih_pyscf.py
@@ -7,10 +7,13 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
+from .test_base_solver import BaseTestSolvers
 
-class TestLiH(unittest.TestCase):
+
+class TestLiH(BaseTestSolvers.BaseTestSolverMolecule):
 
     def setUp(self):
 
@@ -24,10 +27,13 @@ def setUp(self):
             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)
+                                include_all_mo=False, jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -48,37 +54,6 @@ def setUp(self):
         self.solver = SolverSlaterJastrow(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()
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index b97d4cf0..05469bdf 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -8,11 +8,15 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 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_unified import SlaterJastrowUnified as 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):
 
@@ -27,11 +31,19 @@ def setUp(self):
             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)
@@ -65,37 +77,9 @@ def setUp(self):
             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 8908c9c1..ee8e8cae 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -8,7 +8,9 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowBackFlow, SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
 
 
@@ -38,16 +40,26 @@ def setUp(self):
             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 = 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.
         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,
+        self.wf_ref = SlaterJastrow(self.mol_ref, jastrow=jastrow_ref, backflow=None,
                                     kinetic='jacobi',
                                     include_all_mo=True,
                                     configs='single_double(2,2)')
diff --git a/tests/solver/test_lih_pyscf_generic_backflow.py b/tests/solver/test_lih_pyscf_generic_backflow.py
index f04cf100..69c2d6df 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -8,12 +8,15 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 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_unified import SlaterJastrowUnified as 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):
 
@@ -28,12 +31,19 @@ def setUp(self):
             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)
@@ -67,39 +77,9 @@ def setUp(self):
             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_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
similarity index 56%
rename from tests/solver/test_lih_generic_jastrow.py
rename to tests/solver/test_lih_pyscf_generic_jastrow.py
index 8a27862e..23b23dfc 100644
--- a/tests/solver/test_lih_generic_jastrow.py
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -7,12 +7,13 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 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
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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(unittest.TestCase):
+class TestLiH(BaseTestSolvers.BaseTestSolverMolecule):
 
     def setUp(self):
 
@@ -27,11 +28,14 @@ def setUp(self):
             calculator='pyscf',
             basis='sto-3g')
 
+        # jastrow
+        jastrow = JastrowFactor(self.mol, FullyConnectedJastrowKernel)
+
         # wave function
         self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow_kernel=FullyConnectedJastrowKernel,
                                 configs='single(2,2)',
-                                include_all_mo=False)
+                                include_all_mo=False,
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -58,33 +62,8 @@ def setUp(self):
             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)
+    def test2_wf_opt_grad_auto(self):
+        pass
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 4471c4c2..5fa65c2a 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -8,11 +8,15 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 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_unified import SlaterJastrowUnified as 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):
 
@@ -27,11 +31,19 @@ def setUp(self):
             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)
@@ -65,37 +77,9 @@ def setUp(self):
             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/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index d6f40638..faf4ea78 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -7,11 +7,9 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
-from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 
 from qmctorch.utils import set_torch_double_precision
 
@@ -37,7 +35,7 @@ def setUp(self):
             redo_scf=True)
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(
+        jastrow = JastrowFactor(
             mol, PadeJastrowKernel)
 
         # define backflow trans

From 969eb658552505965d7746ded74211d61e78a558 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 12:12:58 +0200
Subject: [PATCH 051/286] remove ref to orb de jastrow

---
 qmctorch/wavefunction/__init__.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 9d7668e5..5dbc02b2 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,5 +1,5 @@
 __all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterCombinedJastrow',
-           'SlaterJastrowBackFlow', 'SlaterOrbitalDependentJastrow',
+           'SlaterJastrowBackFlow',
            'SlaterCombinedJastrowBackflow', 'SlaterJastrowGraph']
 
 from .wf_base import WaveFunction
@@ -7,5 +7,4 @@
 from .slater_combined_jastrow import SlaterCombinedJastrow
 from .slater_jastrow_backflow import SlaterJastrowBackFlow
 from .slater_combined_jastrow_backflow import SlaterCombinedJastrowBackflow
-from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
 from .slater_jastrow_graph import SlaterJastrowGraph

From e18491de4ba6e4c3efbd2f9052241427a538721b Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 12:33:18 +0200
Subject: [PATCH 052/286] fix test wavefunction

---
 .../test_generic_jastrow_orbital.py           | 123 ------------------
 .../jastrows/test_combined_terms.py           |  10 +-
 tests/wavefunction/pooling/test_slater.py     |   7 +-
 .../wavefunction/pooling/test_trace_trick.py  |   6 +-
 4 files changed, 17 insertions(+), 129 deletions(-)
 delete mode 100644 tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py

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
deleted file mode 100644
index b0c3708b..00000000
--- a/tests/wavefunction/jastrows/elec_elec/orbital_dependent/test_generic_jastrow_orbital.py
+++ /dev/null
@@ -1,123 +0,0 @@
-import torch
-from torch.autograd import grad
-
-
-import unittest
-
-import numpy as np
-import torch
-from torch.autograd import Variable, grad, gradcheck
-
-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
-
-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 TestGenericJastrowOrbital(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.nmo = 10
-        self.jastrow = JastrowFactorElectronElectron(
-            self.nup, self.ndown,
-            FullyConnectedJastrowKernel,
-            orbital_dependent_kernel=True,
-            number_of_orbitals=self.nmo
-        )
-        self.nbatch = 11
-
-        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)
-
-        # Warning : using grad on a model made out of ModuleList
-        # automatically summ the values of the grad of the different
-        # modules in the list !
-        assert(torch.allclose(dval.sum(0), 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)
-
-        # Warning : using grad on a model made out of ModuleList
-        # automatically summ the values of the grad of the different
-        # modules in the list !
-        assert torch.allclose(dval.sum(0), 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)
-
-        # Warning : using grad on a model made out of ModuleList
-        # automatically summ the values of the grad of the different
-        # modules in the list !
-        assert torch.allclose(d2val.sum(0), d2val_grad.reshape(
-            self.nbatch, self.nelec, 3).sum(2))
-
-
-if __name__ == "__main__":
-    unittest.main()
-
-    # t = TestGenericJastrowOrbital()
-    # t.setUp()
-    # t.test_jastrow()
-    # t.test_grad_jastrow()
-    # t.test_jacobian_jastrow()
-    # t.test_hess_jastrow()
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index 6c19a47c..e53b5216 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -1,5 +1,5 @@
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
@@ -45,9 +45,13 @@ def setUp(self):
 
         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,
diff --git a/tests/wavefunction/pooling/test_slater.py b/tests/wavefunction/pooling/test_slater.py
index d7df9766..6f310101 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -4,7 +4,8 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
 class TestSlater(unittest.TestCase):
@@ -18,12 +19,16 @@ def setUp(self):
                             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)
diff --git a/tests/wavefunction/pooling/test_trace_trick.py b/tests/wavefunction/pooling/test_trace_trick.py
index 3f1282c5..c97a9e87 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_unified import SlaterJastrowUnified as 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

From f25d1a6ca68708375a8a48fcaffa0addfc0f76f9 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 14:01:30 +0200
Subject: [PATCH 053/286] remove test  values

---
 tests/solver/test_h2_adf.py               |  8 ++++----
 tests/solver/test_h2_adf_jacobi.py        | 12 +++++++-----
 tests/solver/test_h2_pyscf_hamiltonian.py | 10 +++++-----
 tests/solver/test_h2_pyscf_jacobi.py      | 10 +++++-----
 tests/solver/test_h2_pyscf_metropolis.py  | 16 ++++++++--------
 5 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index da70ae24..61c66349 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -52,11 +52,11 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1572532653808594,
-                                -1.1501641653648578]
+        # self.expected_energy = [-1.1572532653808594,
+        #                         -1.1501641653648578]
 
-        self.expected_variance = [0.05085879936814308,
-                                  0.05094174843043177]
+        # 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 ace842e6..02ee9093 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -24,9 +24,11 @@ def setUp(self):
             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)')
+                                configs='single(2,2)', jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -48,11 +50,11 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1571345329284668,
-                                -1.1501641653648578]
+        # self.expected_energy = [-1.1571345329284668,
+        #                         -1.1501641653648578]
 
-        self.expected_variance = [0.05087674409151077,
-                                  0.05094174843043177]
+        # self.expected_variance = [0.05087674409151077,
+        #                           0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index bd52dda4..7c46b2f5 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -58,12 +58,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        # self.expected_energy = [-1.0877732038497925,
+        #                         -1.088576]
 
-        # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        # # values on different arch
+        # self.expected_variance = [0.14341972768306732,
+        #                           0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 25bb7f8d..4cff697b 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -58,12 +58,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        # self.expected_energy = [-1.0877732038497925,
+        #                         -1.088576]
 
-        # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        # # values on different arch
+        # self.expected_variance = [0.14341972768306732,
+        #                           0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 3b8cac67..8057806c 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -67,12 +67,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.1464850902557373,
-                                -1.14937478612449]
+        # self.expected_energy = [-1.1464850902557373,
+        #                         -1.14937478612449]
 
-        # values on different arch
-        self.expected_variance = [0.9279592633247375,
-                                  0.7445300449383236]
+        # # values on different arch
+        # self.expected_variance = [0.9279592633247375,
+        #                           0.7445300449383236]
 
     def test4_geo_opt(self):
 
@@ -104,9 +104,9 @@ def test4_geo_opt(self):
 
 if __name__ == "__main__":
     unittest.main()
-    # t = TestH2()
-    # t.setUp()
+    t = TestH2SamplerMH()
+    t.setUp()
     # # t.test2_single_point_hmc()
-    # # t.test1_single_point()
+    t.test1_single_point()
     # t.test3_wf_opt()
     # # t.test5_sampling_traj()

From b29a43df388f6b807adeb1415d2ecf97c60506d0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 14:17:50 +0200
Subject: [PATCH 054/286] change graph jastrow to take mol as arg

---
 .../jastrows/elec_elec_nuclei/__init__.py     |  3 +++
 .../jastrows/elec_nuclei/__init__.py          |  3 +++
 .../jastrows/graph/jastrow_graph.py           | 17 +++++++------
 .../jastrows/graph/test_graph_jastrow.py      | 24 ++++++++++---------
 4 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index e69de29b..bbb814b9 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -0,0 +1,3 @@
+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
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index e69de29b..226011ff 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -0,0 +1,3 @@
+from .jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei as JastrowFactor
+from .kernels.pade_jastrow_kernel import PadeJastrowKernel
+from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index cab20315..e74a5a9d 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -12,9 +12,7 @@
 
 class JastrowFactorGraph(nn.Module):
 
-    def __init__(self, nup, ndown,
-                 atomic_pos,
-                 atom_types,
+    def __init__(self, mol,
                  ee_model=MGCNPredictor,
                  ee_model_kwargs={},
                  en_model=MGCNPredictor,
@@ -38,9 +36,9 @@ def __init__(self, nup, ndown,
 
         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
@@ -48,10 +46,11 @@ def __init__(self, nup, ndown,
         if self.cuda:
             self.device = torch.device('cuda')
 
-        self.atom_types = atom_types
+        self.atom_types = mol.atoms
         self.atomic_features = atomic_features
-        self.atoms = atomic_pos.to(self.device)
-        self.natoms = atomic_pos.shape[0]
+        self.atoms = torch.as_tensor(
+            mol.atom_coords).to(self.device)
+        self.natoms = self.atoms.shape[0]
 
         self.requires_autograd = True
 
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index dc454449..a9bb3d1b 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -2,11 +2,11 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-
+from types import SimpleNamespace
 from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
 from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
 
-torch.set_default_tensor_type(torch.FloatTensor)
+torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 def hess(out, pos):
@@ -42,12 +42,14 @@ def setUp(self):
 
         self.nup, self.ndown = 2, 2
         self.nelec = self.nup + self.ndown
-        self.atomic_pos = torch.rand(2, 3)
-
+        self.atomic_pos = np.random.rand(2, 3)
         self.atom_types = ["Li", "H"]
-        self.jastrow = JastrowFactorGraph(self.nup, self.ndown,
-                                          self.atomic_pos,
-                                          self.atom_types,
+
+        self.mol = SimpleNamespace(nup=self.nup, ndown=self.ndown,
+                                   atom_coords=self.atomic_pos,
+                                   atoms=self.atom_types)
+
+        self.jastrow = JastrowFactorGraph(self.mol,
                                           ee_model=MGCNPredictor,
                                           ee_model_kwargs={'n_layers': 3,
                                                            'feats': 32,
@@ -125,10 +127,10 @@ def test_hess_jastrow(self):
 
 
 if __name__ == "__main__":
-    # unittest.main()
-    t = TestGraphJastrow()
-    t.setUp()
-    t.test_permutation()
+    unittest.main()
+    # t = TestGraphJastrow()
+    # t.setUp()
+    # t.test_permutation()
     # t.test_grad_jastrow()
     # t.test_sum_grad_jastrow()
     # t.test_hess_jastrow()

From c05da7dd52bcf131de7641e3a50bc26be1b45e8f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 14:21:08 +0200
Subject: [PATCH 055/286] remove assert on expected energy in the base class

---
 tests/solver/test_base_solver.py          | 12 ++++++------
 tests/solver/test_h2_adf.py               |  8 ++++----
 tests/solver/test_h2_adf_jacobi.py        |  8 ++++----
 tests/solver/test_h2_pyscf_hamiltonian.py | 10 +++++-----
 tests/solver/test_h2_pyscf_jacobi.py      | 10 +++++-----
 tests/solver/test_h2_pyscf_metropolis.py  | 10 +++++-----
 6 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 5fbc592a..594eb2f6 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -25,13 +25,13 @@ def test1_single_point(self):
             obs = self.solver.single_point()
             e, v = obs.energy, obs.variance
 
-            if self.expected_energy is not None:
-                assert(
-                    np.any(np.isclose(e.data.item(), np.array(self.expected_energy))))
+            # if self.expected_energy is not None:
+            #     assert(
+            #         np.any(np.isclose(e.data.item(), np.array(self.expected_energy))))
 
-            if self.expected_variance is not None:
-                assert(
-                    np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
+            # if self.expected_variance is not None:
+            #     assert(
+            #         np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
 
         def test2_wf_opt_grad_auto(self):
 
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index 61c66349..da70ae24 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -52,11 +52,11 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # vals on different archs
-        # self.expected_energy = [-1.1572532653808594,
-        #                         -1.1501641653648578]
+        self.expected_energy = [-1.1572532653808594,
+                                -1.1501641653648578]
 
-        # self.expected_variance = [0.05085879936814308,
-        #                           0.05094174843043177]
+        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 02ee9093..0a172ab9 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -50,11 +50,11 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # vals on different archs
-        # self.expected_energy = [-1.1571345329284668,
-        #                         -1.1501641653648578]
+        self.expected_energy = [-1.1571345329284668,
+                                -1.1501641653648578]
 
-        # self.expected_variance = [0.05087674409151077,
-        #                           0.05094174843043177]
+        self.expected_variance = [0.05087674409151077,
+                                  0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index 7c46b2f5..bd52dda4 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -58,12 +58,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        # self.expected_energy = [-1.0877732038497925,
-        #                         -1.088576]
+        self.expected_energy = [-1.0877732038497925,
+                                -1.088576]
 
-        # # values on different arch
-        # self.expected_variance = [0.14341972768306732,
-        #                           0.163771]
+        # values on different arch
+        self.expected_variance = [0.14341972768306732,
+                                  0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 4cff697b..25bb7f8d 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -58,12 +58,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        # self.expected_energy = [-1.0877732038497925,
-        #                         -1.088576]
+        self.expected_energy = [-1.0877732038497925,
+                                -1.088576]
 
-        # # values on different arch
-        # self.expected_variance = [0.14341972768306732,
-        #                           0.163771]
+        # values on different arch
+        self.expected_variance = [0.14341972768306732,
+                                  0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 8057806c..9e8414be 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -67,12 +67,12 @@ def setUp(self):
                                           optimizer=self.opt)
 
         # values on different arch
-        # self.expected_energy = [-1.1464850902557373,
-        #                         -1.14937478612449]
+        self.expected_energy = [-1.1464850902557373,
+                                -1.14937478612449]
 
-        # # values on different arch
-        # self.expected_variance = [0.9279592633247375,
-        #                           0.7445300449383236]
+        # values on different arch
+        self.expected_variance = [0.9279592633247375,
+                                  0.7445300449383236]
 
     def test4_geo_opt(self):
 

From 236976dd30082cca7658ffea63c48262f214c73b Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 14:33:33 +0200
Subject: [PATCH 056/286] updated example

---
 example/autocorrelation/h2.py        | 14 ++++++++++----
 example/backflow/backflow.py         | 21 ++++++++++++++++-----
 example/gpu/h2.py                    |  8 +++++++-
 example/optimization/h2.py           | 11 +++++++----
 example/single_point/h2.py           |  7 +++++--
 example/single_point/h2o_sampling.py |  8 ++++++--
 6 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/example/autocorrelation/h2.py b/example/autocorrelation/h2.py
index cef59fb4..2aea90de 100644
--- a/example/autocorrelation/h2.py
+++ b/example/autocorrelation/h2.py
@@ -5,8 +5,8 @@
 from qmctorch.scf import Molecule
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
-from qmctorch.wavefunction import SlaterJastrow
-
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 torch.manual_seed(0)
 
 # molecule
@@ -16,8 +16,13 @@
     calculator='pyscf',
     basis='sto-3g')
 
-# wave function
+
+# jastrow
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+# wave funtion
 wf = SlaterJastrow(mol, kinetic='auto',
+                   jastrow=jastrow,
                    configs='single(2,2)')
 
 # sampler
@@ -43,5 +48,6 @@
 
 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)
+iat = plot_integrated_autocorrelation_time(
+    obs.local_energy, rho=rho, C=5)
 print(f"integrated autocorrelation time: {iat}")
diff --git a/example/backflow/backflow.py b/example/backflow/backflow.py
index 7f083aae..cdc793ca 100644
--- a/example/backflow/backflow.py
+++ b/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_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
 class MyBackflow(BackFlowKernelBase):
@@ -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/example/gpu/h2.py b/example/gpu/h2.py
index 1ded350d..e24ba71e 100644
--- a/example/gpu/h2.py
+++ b/example/gpu/h2.py
@@ -1,7 +1,8 @@
 from torch import optim
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
@@ -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/example/optimization/h2.py b/example/optimization/h2.py
index e6dfc44b..5240aa9f 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -2,13 +2,13 @@
 from torch import optim
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+
 from qmctorch.solver import SolverSlaterJastrow
 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.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
@@ -23,10 +23,13 @@
                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)
+                   jastrow=jastrow)
 
 # sampler
 sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
diff --git a/example/single_point/h2.py b/example/single_point/h2.py
index 10762f3a..44a34e41 100644
--- a/example/single_point/h2.py
+++ b/example/single_point/h2.py
@@ -1,5 +1,6 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils import plot_walkers_traj
@@ -10,10 +11,12 @@
 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').gto2sto()
+                   configs='ground_state', jastrow=jastrow).gto2sto()
 
 # sampler
 sampler = Metropolis(nwalkers=1000, nstep=1000, step_size=0.25,
diff --git a/example/single_point/h2o_sampling.py b/example/single_point/h2o_sampling.py
index a605cce8..420e504a 100644
--- a/example/single_point/h2o_sampling.py
+++ b/example/single_point/h2o_sampling.py
@@ -1,5 +1,6 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils import plot_walkers_traj
@@ -9,9 +10,12 @@
 mol = Molecule(atom='water.xyz', unit='angs',
                calculator='pyscf', basis='sto-3g', name='water')
 
+# 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=100, nstep=500, step_size=0.25,

From 7cb15741b3e7f165a4e82b04675738713e1169b9 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 14:47:02 +0200
Subject: [PATCH 057/286] fix test graph

---
 example/autocorrelation/h2.py                 |   2 +-
 example/backflow/backflow.py                  |   2 +-
 example/gpu/h2.py                             |   2 +-
 example/optimization/h2.py                    |   2 +-
 example/single_point/h2.py                    |   2 +-
 example/single_point/h2o_sampling.py          |   2 +-
 notebooks/test.ipynb                          |   2 +-
 qmctorch/wavefunction/__init__.py             |   8 +-
 .../wavefunction/jastrows/graph/__init__.py   |   2 +
 qmctorch/wavefunction/slater_jastrow.py       | 450 +++++++++++-
 .../wavefunction/slater_jastrow_unified.py    | 671 ------------------
 .../{ => trash}/slater_combined_jastrow.py    |   0
 .../slater_combined_jastrow_backflow.py       |   0
 qmctorch/wavefunction/trash/slater_jastrow.py | 273 +++++++
 .../{ => trash}/slater_jastrow_backflow.py    |   0
 .../{ => trash}/slater_jastrow_base.py        |   0
 .../{ => trash}/slater_jastrow_graph.py       |   0
 tests/sampler/test_sampler_base.py            |   2 +-
 tests/scf/test_gto2sto_fit.py                 |   2 +-
 tests/solver/test_h2_adf.py                   |   2 +-
 tests/solver/test_h2_adf_jacobi.py            |   2 +-
 tests/solver/test_h2_pyscf_geo_opt.py         |   2 +-
 tests/solver/test_h2_pyscf_hamiltonian.py     |   2 +-
 tests/solver/test_h2_pyscf_jacobi.py          |   2 +-
 tests/solver/test_h2_pyscf_metropolis.py      |   2 +-
 tests/solver/test_h2_pyscf_stats.py           |   2 +-
 tests/solver/test_lih_adf_backflow.py         |   2 +-
 tests/solver/test_lih_pyscf.py                |   2 +-
 tests/solver/test_lih_pyscf_backflow.py       |   2 +-
 .../solver/test_lih_pyscf_compare_backflow.py |   2 +-
 .../solver/test_lih_pyscf_generic_backflow.py |   2 +-
 .../solver/test_lih_pyscf_generic_jastrow.py  |   3 +-
 ...st_lih_pyscf_orbital_dependent_backflow.py |   2 +-
 tests/utils/test_interpolate.py               |   2 +-
 .../orbitals/test_mo_values_adf.py            |   2 +-
 tests/wavefunction/pooling/test_slater.py     |   2 +-
 .../wavefunction/pooling/test_trace_trick.py  |   2 +-
 .../test_compare_slaterjastrow_backflow.py    |   2 +-
 ...laterjastrow_orbital_dependent_backflow.py |   2 +-
 .../test_slatercombinedjastrow.py             |   2 +-
 .../test_slatercombinedjastrow_backflow.py    |   2 +-
 tests/wavefunction/test_slaterjastrow.py      |   2 +-
 .../test_slaterjastrow_backflow.py            |   2 +-
 tests/wavefunction/test_slaterjastrow_cas.py  |   2 +-
 .../test_slaterjastrow_ee_cusp.py             |   2 +-
 .../test_slaterjastrow_generic.py             |   2 +-
 ...laterjastrow_orbital_dependent_backflow.py |   2 +-
 .../test_slaterjastrow_unified.py             |   2 +-
 tests/wavefunction/test_slaterjastrowgraph.py |  35 +-
 tests_hvd/test_h2_hvd.py                      |   2 +-
 50 files changed, 759 insertions(+), 759 deletions(-)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/__init__.py
 delete mode 100644 qmctorch/wavefunction/slater_jastrow_unified.py
 rename qmctorch/wavefunction/{ => trash}/slater_combined_jastrow.py (100%)
 rename qmctorch/wavefunction/{ => trash}/slater_combined_jastrow_backflow.py (100%)
 create mode 100644 qmctorch/wavefunction/trash/slater_jastrow.py
 rename qmctorch/wavefunction/{ => trash}/slater_jastrow_backflow.py (100%)
 rename qmctorch/wavefunction/{ => trash}/slater_jastrow_base.py (100%)
 rename qmctorch/wavefunction/{ => trash}/slater_jastrow_graph.py (100%)

diff --git a/example/autocorrelation/h2.py b/example/autocorrelation/h2.py
index 2aea90de..00cf3ccc 100644
--- a/example/autocorrelation/h2.py
+++ b/example/autocorrelation/h2.py
@@ -5,7 +5,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 torch.manual_seed(0)
 
diff --git a/example/backflow/backflow.py b/example/backflow/backflow.py
index cdc793ca..abc4de98 100644
--- a/example/backflow/backflow.py
+++ b/example/backflow/backflow.py
@@ -8,7 +8,7 @@
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
 
 
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
diff --git a/example/gpu/h2.py b/example/gpu/h2.py
index e24ba71e..0feb3cba 100644
--- a/example/gpu/h2.py
+++ b/example/gpu/h2.py
@@ -1,7 +1,7 @@
 from torch import optim
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.sampler import Metropolis
diff --git a/example/optimization/h2.py b/example/optimization/h2.py
index 5240aa9f..dac6d569 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -7,7 +7,7 @@
 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.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 # bond distance : 0.74 A -> 1.38 a
diff --git a/example/single_point/h2.py b/example/single_point/h2.py
index 44a34e41..881e84ae 100644
--- a/example/single_point/h2.py
+++ b/example/single_point/h2.py
@@ -1,5 +1,5 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 SolverSlaterJastrow
diff --git a/example/single_point/h2o_sampling.py b/example/single_point/h2o_sampling.py
index 420e504a..044c8bb1 100644
--- a/example/single_point/h2o_sampling.py
+++ b/example/single_point/h2o_sampling.py
@@ -1,5 +1,5 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 SolverSlaterJastrow
diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index 165a2b45..47f98cd7 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -124,7 +124,7 @@
     }
    ],
    "source": [
-    "from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow\n",
+    "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",
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 5dbc02b2..45344abe 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,10 +1,4 @@
-__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterCombinedJastrow',
-           'SlaterJastrowBackFlow',
-           'SlaterCombinedJastrowBackflow', 'SlaterJastrowGraph']
+__all__ = ['WaveFunction', 'SlaterJastrow']
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-from .slater_combined_jastrow import SlaterCombinedJastrow
-from .slater_jastrow_backflow import SlaterJastrowBackFlow
-from .slater_combined_jastrow_backflow import SlaterCombinedJastrowBackflow
-from .slater_jastrow_graph import SlaterJastrowGraph
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
new file mode 100644
index 00000000..600125c6
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -0,0 +1,2 @@
+from .jastrow_graph import JastrowFactorGraph as JastrowFactor
+from .mgcn.mgcn_predictor import MGCNPredictor
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 81b84492..59b06029 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,19 +1,30 @@
 
 
-import numpy as np
 import torch
-from .slater_jastrow_base import SlaterJastrowBase
+from scipy.optimize import curve_fit
+from copy import deepcopy
+import matplotlib.pyplot as plt
+import numpy as np
+from torch import nn
+import operator
 
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .. import log
 
+from .wf_base import WaveFunction
+from .orbitals.atomic_orbitals import AtomicOrbitals
+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
 
-class SlaterJastrow(SlaterJastrowBase):
 
-    def __init__(self, mol, configs='ground_state',
+class SlaterJastrow(WaveFunction):
+
+    def __init__(self, mol,
+                 jastrow=None,
+                 backflow=None,
+                 configs='ground_state',
                  kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
                  cuda=False,
                  include_all_mo=True):
         """Implementation of the QMC Network.
@@ -24,6 +35,8 @@ def __init__(self, mol, configs='ground_state',
             kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
             jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
             jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
             cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
             include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
                                              popualted in the configs. Defaults to False
@@ -32,27 +45,161 @@ 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)
+
+        # init the mo mixer layer
+        self.init_mo_mixer()
+
+        # 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_scf',
+                                   'mo', 'jastrow',
+                                   'pool', 'fc'])
+
+        self.log_data()
+
+    def init_atomic_orb(self, backflow):
+        """Initialize the atomic orbital layer."""
+        self.backflow = backflow
+        if self.backflow is None:
+            self.ao = AtomicOrbitals(self.mol, self.cuda)
+        else:
+            self.ao = AtomicOrbitalsBackFlow(
+                self.mol, self.backflow, self.cuda)
+
+        if self.cuda:
+            self.ao = self.ao.to(self.device)
+
+    def init_molecular_orb(self, include_all_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
+
+        # scf layer
+        self.mo_scf = nn.Linear(
+            self.mol.basis.nao, self.nmo_opt, bias=False)
+        self.mo_scf.weight = self.get_mo_coeffs()
+        self.mo_scf.weight.requires_grad = False
+
+        # port the layer to cuda if needed
+        if self.cuda:
+            self.mo_scf.to(self.device)
+
+    def init_mo_mixer(self):
+        """Init the mo mixer layer"""
 
-        # process the Jastrow
-        if jastrow_kernel is not None:
+        # mo mixer layer
+        self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
 
+        # init the weight to idenity matrix
+        self.mo.weight = nn.Parameter(
+            torch.eye(self.nmo_opt, self.nmo_opt))
+
+        # put on the card if needed
+        if self.cuda:
+            self.mo.to(self.device)
+
+    def init_config(self, configs):
+        """Initialize the electronic configurations desired in the wave function."""
+
+        # define the SD we want
+        self.orb_confs = OrbitalConfigurations(self.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
+
+    def init_slater_det_calculator(self):
+        """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):
+        """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.)
+        self.fc.weight.data[0][0] = 1.
+
+        # port to card
+        if self.cuda:
+            self.fc = self.fc.to(self.device)
+
+    def init_jastrow(self, jastrow):
+        """Init the jastrow factor calculator"""
+
+        self.jastrow = jastrow
+
+        if self.jastrow is None:
+            self.use_jastrow = False
+
+        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)
+            self.jastrow_type = self.jastrow.__repr__()
 
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
 
-        self.log_data()
+    def init_kinetic(self, kinetic, backflow):
+        """"Init the calculator of the kinetic energies"""
+
+        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, ao=None):
         """computes the value of the wave function for the sampling points
 
         .. math::
-            \\Psi(R) =  \\sum_{n} c_n J(R) D^{u}_n(r^u) \\times D^{d}_n(r^d)
+            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)
@@ -68,6 +215,7 @@ def forward(self, x, ao=None):
             >>> vals = wf(pos)
         """
 
+        # compute the jastrow from the pos
         if self.use_jastrow:
             J = self.jastrow(x)
 
@@ -86,6 +234,7 @@ def forward(self, x, ao=None):
         # pool the mos
         x = self.pool(x)
 
+        # compute the CI and return
         if self.use_jastrow:
             return J * self.fc(x)
 
@@ -93,21 +242,24 @@ def forward(self, x, ao=None):
             return self.fc(x)
 
     def ao2mo(self, ao):
-        return self.mo(self.mo_scf(ao))
+        """transforms AO values in to MO values."""
 
-    def pos2mo(self, x, derivative=0):
-        """Get the values of MOs
+        return self.mo(self.mo_scf(ao))
 
-        Arguments:
-            x {torch.tensor} -- positions of the electrons [nbatch, nelec*ndim]
+    def pos2mo(self, x, derivative=0, sum_grad=True):
+        """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)))
+
+        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.
@@ -133,6 +285,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)
 
@@ -271,3 +424,248 @@ 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,  **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_backflow(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')
+
+    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):
+        """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 nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
+
+    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):
+        """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, self.jastrow, backflow=self.backflow,
+                              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_unified.py b/qmctorch/wavefunction/slater_jastrow_unified.py
deleted file mode 100644
index 36a82d42..00000000
--- a/qmctorch/wavefunction/slater_jastrow_unified.py
+++ /dev/null
@@ -1,671 +0,0 @@
-
-
-import torch
-from scipy.optimize import curve_fit
-from copy import deepcopy
-import matplotlib.pyplot as plt
-import numpy as np
-from torch import nn
-import operator
-
-from .. import log
-
-from .wf_base import WaveFunction
-from .orbitals.atomic_orbitals import AtomicOrbitals
-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
-
-
-class SlaterJastrowUnified(WaveFunction):
-
-    def __init__(self, mol,
-                 jastrow=None,
-                 backflow=None,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
-        """Implementation of the QMC Network.
-
-        Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
-            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
-            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
-            backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
-            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
-            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
-                                             popualted in the configs. Defaults to False
-        Examples::
-            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-        """
-
-        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)
-
-        # init the mo mixer layer
-        self.init_mo_mixer()
-
-        # 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_scf',
-                                   'mo', 'jastrow',
-                                   'pool', 'fc'])
-
-        self.log_data()
-
-    def init_atomic_orb(self, backflow):
-        """Initialize the atomic orbital layer."""
-        self.backflow = backflow
-        if self.backflow is None:
-            self.ao = AtomicOrbitals(self.mol, self.cuda)
-        else:
-            self.ao = AtomicOrbitalsBackFlow(
-                self.mol, self.backflow, self.cuda)
-
-        if self.cuda:
-            self.ao = self.ao.to(self.device)
-
-    def init_molecular_orb(self, include_all_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
-
-        # scf layer
-        self.mo_scf = nn.Linear(
-            self.mol.basis.nao, self.nmo_opt, bias=False)
-        self.mo_scf.weight = self.get_mo_coeffs()
-        self.mo_scf.weight.requires_grad = False
-
-        # port the layer to cuda if needed
-        if self.cuda:
-            self.mo_scf.to(self.device)
-
-    def init_mo_mixer(self):
-        """Init the mo mixer layer"""
-
-        # mo mixer layer
-        self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
-
-        # init the weight to idenity matrix
-        self.mo.weight = nn.Parameter(
-            torch.eye(self.nmo_opt, self.nmo_opt))
-
-        # put on the card if needed
-        if self.cuda:
-            self.mo.to(self.device)
-
-    def init_config(self, configs):
-        """Initialize the electronic configurations desired in the wave function."""
-
-        # define the SD we want
-        self.orb_confs = OrbitalConfigurations(self.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
-
-    def init_slater_det_calculator(self):
-        """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):
-        """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.)
-        self.fc.weight.data[0][0] = 1.
-
-        # port to card
-        if self.cuda:
-            self.fc = self.fc.to(self.device)
-
-    def init_jastrow(self, jastrow):
-        """Init the jastrow factor calculator"""
-
-        self.jastrow = jastrow
-
-        if self.jastrow is None:
-            self.use_jastrow = False
-
-        else:
-            self.use_jastrow = True
-            self.jastrow_type = self.jastrow.__repr__()
-
-            if self.cuda:
-                self.jastrow = self.jastrow.to(self.device)
-
-    def init_kinetic(self, kinetic, backflow):
-        """"Init the calculator of the kinetic energies"""
-
-        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, 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.
-        C. Filippi, Simple Formalism for Efficient Derivatives .
-
-        .. math::
-             \\frac{\Delta \\Psi(R)}{ \\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\\Delta D_n^u}{D_n^u} + \\frac{\\Delta D_n^d}{D_n^d}) D_n^u D_n^d
-
-        We compute the laplacian of the determinants through the Jacobi formula
-
-        .. math::
-            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A)
-
-        Here A = J(R) phi and therefore :
-
-        .. math::
-            \\Delta A = (\\Delta J) D + 2 \\nabla J \\nabla D + (\\Delta D) J
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            torch.tensor: values of the kinetic energy at each sampling points
-        """
-
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
-
-        mo = self.ao2mo(ao)
-        bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
-
-        kin = self.pool.operator(mo, bkin)
-        psi = self.pool(mo)
-        out = self.fc(kin * psi) / self.fc(psi)
-        return out
-
-    def gradients_jacobi(self, x, sum_grad=False, 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})
-
-        The gradients of the wave function
-
-        .. math:
-            \\Psi(R) = J(R) \\sum_n c_n D^{u}_n D^{d}_n = J(R) \\Sigma
-
-        are computed following
-
-        .. math::
-            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \Sigma \\right)
-
-        with
-
-        .. math::
-
-            \\nabla \\Sigma =  \\sum_n c_n (\\frac{\\nabla D^u_n}{D^u_n} + \\frac{\\nabla D^d_n}{D^d_n}) D^u_n D^d_n
-
-        that we compute with the Jacobi formula as:
-
-        .. math::
-
-            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
-
-        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
-        """
-
-        # compute the mo values
-        mo = self.ao2mo(self.ao(x))
-
-        # compute the gradient operator matrix
-        grad_ao = self.ao(x, derivative=1, sum_grad=False)
-
-        # compute the derivatives of the MOs
-        dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
-        dmo = dmo.permute(3, 0, 1, 2)
-
-        # stride the tensor
-        eye = torch.eye(self.nelec).to(self.device)
-        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
-
-        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(2, 0, 1, 3, 4)
-
-        # flatten to have Nelec*Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.reshape(-1, *(dmo.shape[2:]))
-
-        # use the Jacobi formula to compute the value
-        # the grad of each determinants and sum up the terms :
-        # Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)
-        grad_dets = self.pool.operator(mo, dmo)
-
-        # compute the determinants
-        # D^u_n D^d_n
-        dets = self.pool(mo)
-
-        # assemble the final values of \nabla \Sigma
-        # \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
-        out = self.fc(grad_dets * dets)
-        out = out.transpose(0, 1).squeeze()
-
-        if self.use_jastrow:
-
-            nbatch = x.shape[0]
-
-            # nbatch x 1
-            jast = self.jastrow(x)
-
-            # nbatch x ndim x nelec
-            grad_jast = self.jastrow(x, derivative=1, sum_grad=False)
-
-            # reorder grad_jast to nbtach x Nelec x Ndim
-            grad_jast = grad_jast.permute(0, 2, 1)
-
-            # compute J(R) (\nabla\Sigma)
-            out = jast*out
-
-            # add the product (\nabla J(R)) \Sigma
-            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
-        if pdf:
-            out = 2 * out * self.fc(dets)
-            if self.use_jastrow:
-                out = out * jast
-
-        return out
-
-    def get_kinetic_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
-        """
-
-        bkin = self.ao2mo(d2ao)
-
-        if self.use_jastrow:
-
-            jast, djast, d2jast = self.jastrow(x,
-                                               derivative=[0, 1, 2],
-                                               sum_grad=False)
-
-            djast = djast.transpose(1, 2) / jast.unsqueeze(-1)
-            d2jast = d2jast / jast
-
-            dmo = self.ao2mo(dao.transpose(2, 3)).transpose(2, 3)
-
-            djast_dmo = (djast.unsqueeze(2) * dmo).sum(-1)
-            d2jast_mo = d2jast.unsqueeze(-1) * mo
-
-            bkin = bkin + 2 * djast_dmo + d2jast_mo
-
-        return -0.5 * bkin
-
-    def kinetic_energy_jacobi_backflow(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_backflow(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')
-
-    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):
-        """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 nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
-
-    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):
-        """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, self.jastrow, backflow=self.backflow,
-                              configs=self.configs_method,
-                              kinetic=self.kinetic_method,
-                              cuda=self.cuda,
-                              include_all_mo=self.include_all_mo)
diff --git a/qmctorch/wavefunction/slater_combined_jastrow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
similarity index 100%
rename from qmctorch/wavefunction/slater_combined_jastrow.py
rename to qmctorch/wavefunction/trash/slater_combined_jastrow.py
diff --git a/qmctorch/wavefunction/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
similarity index 100%
rename from qmctorch/wavefunction/slater_combined_jastrow_backflow.py
rename to qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
diff --git a/qmctorch/wavefunction/trash/slater_jastrow.py b/qmctorch/wavefunction/trash/slater_jastrow.py
new file mode 100644
index 00000000..81b84492
--- /dev/null
+++ b/qmctorch/wavefunction/trash/slater_jastrow.py
@@ -0,0 +1,273 @@
+
+
+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
+
+
+class SlaterJastrow(SlaterJastrowBase):
+
+    def __init__(self, mol, configs='ground_state',
+                 kinetic='jacobi',
+                 jastrow_kernel=PadeJastrowKernel,
+                 jastrow_kernel_kwargs={},
+                 cuda=False,
+                 include_all_mo=True):
+        """Implementation of the QMC Network.
+
+        Args:
+            mol (qmc.wavefunction.Molecule): a molecule object
+            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
+            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
+            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
+            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
+                                             popualted in the configs. Defaults to False
+        Examples::
+            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
+            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
+        """
+
+        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
+
+        # process the Jastrow
+        if jastrow_kernel is not None:
+
+            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)
+
+            if self.cuda:
+                self.jastrow = self.jastrow.to(self.device)
+
+        self.log_data()
+
+    def forward(self, x, ao=None):
+        """computes the value of the wave function for the sampling points
+
+        .. math::
+            \\Psi(R) =  \\sum_{n} c_n J(R) D^{u}_n(r^u) \\times D^{d}_n(r^d)
+
+        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)
+        """
+
+        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)
+
+        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))
+
+    def pos2mo(self, x, derivative=0):
+        """Get the values of MOs
+
+        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]
+        """
+        return self.mo(self.mo_scf(self.ao(x, derivative=derivative)))
+
+    def kinetic_energy_jacobi(self, x, **kwargs):
+        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        C. Filippi, Simple Formalism for Efficient Derivatives .
+
+        .. math::
+             \\frac{\Delta \\Psi(R)}{ \\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\\Delta D_n^u}{D_n^u} + \\frac{\\Delta D_n^d}{D_n^d}) D_n^u D_n^d
+
+        We compute the laplacian of the determinants through the Jacobi formula
+
+        .. math::
+            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A)
+
+        Here A = J(R) phi and therefore :
+
+        .. math::
+            \\Delta A = (\\Delta J) D + 2 \\nabla J \\nabla D + (\\Delta D) J
+        Args:
+            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
+
+        Returns:
+            torch.tensor: values of the kinetic energy at each sampling points
+        """
+
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
+        mo = self.ao2mo(ao)
+        bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
+
+        kin = self.pool.operator(mo, bkin)
+        psi = self.pool(mo)
+        out = self.fc(kin * psi) / self.fc(psi)
+        return out
+
+    def gradients_jacobi(self, x, sum_grad=False, 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})
+
+        The gradients of the wave function
+
+        .. math:
+            \\Psi(R) = J(R) \\sum_n c_n D^{u}_n D^{d}_n = J(R) \\Sigma
+
+        are computed following
+
+        .. math::
+            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \Sigma \\right)
+
+        with
+
+        .. math::
+
+            \\nabla \\Sigma =  \\sum_n c_n (\\frac{\\nabla D^u_n}{D^u_n} + \\frac{\\nabla D^d_n}{D^d_n}) D^u_n D^d_n
+
+        that we compute with the Jacobi formula as:
+
+        .. math::
+
+            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
+
+        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
+        """
+
+        # compute the mo values
+        mo = self.ao2mo(self.ao(x))
+
+        # compute the gradient operator matrix
+        grad_ao = self.ao(x, derivative=1, sum_grad=False)
+
+        # compute the derivatives of the MOs
+        dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
+        dmo = dmo.permute(3, 0, 1, 2)
+
+        # stride the tensor
+        eye = torch.eye(self.nelec).to(self.device)
+        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
+
+        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
+        dmo = dmo.permute(2, 0, 1, 3, 4)
+
+        # flatten to have Nelec*Ndim, Nbatch, Nelec, Nmo
+        dmo = dmo.reshape(-1, *(dmo.shape[2:]))
+
+        # use the Jacobi formula to compute the value
+        # the grad of each determinants and sum up the terms :
+        # Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)
+        grad_dets = self.pool.operator(mo, dmo)
+
+        # compute the determinants
+        # D^u_n D^d_n
+        dets = self.pool(mo)
+
+        # assemble the final values of \nabla \Sigma
+        # \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
+        out = self.fc(grad_dets * dets)
+        out = out.transpose(0, 1).squeeze()
+
+        if self.use_jastrow:
+
+            nbatch = x.shape[0]
+
+            # nbatch x 1
+            jast = self.jastrow(x)
+
+            # nbatch x ndim x nelec
+            grad_jast = self.jastrow(x, derivative=1, sum_grad=False)
+
+            # reorder grad_jast to nbtach x Nelec x Ndim
+            grad_jast = grad_jast.permute(0, 2, 1)
+
+            # compute J(R) (\nabla\Sigma)
+            out = jast*out
+
+            # add the product (\nabla J(R)) \Sigma
+            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
+        if pdf:
+            out = 2 * out * self.fc(dets)
+            if self.use_jastrow:
+                out = out * jast
+
+        return out
+
+    def get_kinetic_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
+        """
+
+        bkin = self.ao2mo(d2ao)
+
+        if self.use_jastrow:
+
+            jast, djast, d2jast = self.jastrow(x,
+                                               derivative=[0, 1, 2],
+                                               sum_grad=False)
+
+            djast = djast.transpose(1, 2) / jast.unsqueeze(-1)
+            d2jast = d2jast / jast
+
+            dmo = self.ao2mo(dao.transpose(2, 3)).transpose(2, 3)
+
+            djast_dmo = (djast.unsqueeze(2) * dmo).sum(-1)
+            d2jast_mo = d2jast.unsqueeze(-1) * mo
+
+            bkin = bkin + 2 * djast_dmo + d2jast_mo
+
+        return -0.5 * bkin
diff --git a/qmctorch/wavefunction/slater_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
similarity index 100%
rename from qmctorch/wavefunction/slater_jastrow_backflow.py
rename to qmctorch/wavefunction/trash/slater_jastrow_backflow.py
diff --git a/qmctorch/wavefunction/slater_jastrow_base.py b/qmctorch/wavefunction/trash/slater_jastrow_base.py
similarity index 100%
rename from qmctorch/wavefunction/slater_jastrow_base.py
rename to qmctorch/wavefunction/trash/slater_jastrow_base.py
diff --git a/qmctorch/wavefunction/slater_jastrow_graph.py b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
similarity index 100%
rename from qmctorch/wavefunction/slater_jastrow_graph.py
rename to qmctorch/wavefunction/trash/slater_jastrow_graph.py
diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index 62325546..b29547b1 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -5,7 +5,7 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/scf/test_gto2sto_fit.py b/tests/scf/test_gto2sto_fit.py
index 684ec559..31f39f4d 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -5,7 +5,7 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index da70ae24..96d7a4c7 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -1,6 +1,6 @@
 from ..path_utils import PATH_TEST
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.scf import Molecule
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.sampler import Metropolis
diff --git a/tests/solver/test_h2_adf_jacobi.py b/tests/solver/test_h2_adf_jacobi.py
index 0a172ab9..1d07a041 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -8,7 +8,7 @@
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from ..path_utils import PATH_TEST
 from .test_base_solver import BaseTestSolvers
 
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index 60c2aac2..cf70ba2b 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -12,7 +12,7 @@
                             plot_integrated_autocorrelation_time,
                             plot_walkers_traj)
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 __PLOT__ = True
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index bd52dda4..05cc3337 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -10,7 +10,7 @@
 from qmctorch.solver import SolverSlaterJastrow
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 __PLOT__ = True
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 25bb7f8d..4c1c05e1 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -10,7 +10,7 @@
 from qmctorch.solver import SolverSlaterJastrow
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 __PLOT__ = True
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 9e8414be..2d9dea80 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -14,7 +14,7 @@
                             plot_integrated_autocorrelation_time,
                             plot_walkers_traj)
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 __PLOT__ = True
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index f4cfebb6..25fe80ef 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -12,7 +12,7 @@
                             plot_walkers_traj)
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 
 class TestH2Stat(unittest.TestCase):
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index a63b463a..f6ebc661 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -9,7 +9,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
 from ..path_utils import PATH_TEST
diff --git a/tests/solver/test_lih_pyscf.py b/tests/solver/test_lih_pyscf.py
index 35958e4c..e9dea63e 100644
--- a/tests/solver/test_lih_pyscf.py
+++ b/tests/solver/test_lih_pyscf.py
@@ -7,7 +7,7 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 from .test_base_solver import BaseTestSolvers
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 05469bdf..0f4baa47 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -10,7 +10,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
 from .test_base_solver import BaseTestSolvers
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index ee8e8cae..5e31aa5b 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -8,7 +8,7 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/solver/test_lih_pyscf_generic_backflow.py b/tests/solver/test_lih_pyscf_generic_backflow.py
index 69c2d6df..f48d39f2 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -10,7 +10,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelPowerSum
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
 from .test_base_solver import BaseTestSolvers
diff --git a/tests/solver/test_lih_pyscf_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
index 23b23dfc..abe95f17 100644
--- a/tests/solver/test_lih_pyscf_generic_jastrow.py
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -7,12 +7,13 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+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):
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 5fa65c2a..b0dd9610 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -10,7 +10,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
 from .test_base_solver import BaseTestSolvers
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 60bb16db..9f74dbf1 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -5,7 +5,7 @@
 from qmctorch.utils import (InterpolateAtomicOrbitals,
                             InterpolateMolecularOrbitals)
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/orbitals/test_mo_values_adf.py b/tests/wavefunction/orbitals/test_mo_values_adf.py
index 3a16cc09..331cdfe5 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.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 from ...path_utils import PATH_TEST
 
diff --git a/tests/wavefunction/pooling/test_slater.py b/tests/wavefunction/pooling/test_slater.py
index 6f310101..8baf5130 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -4,7 +4,7 @@
 
 from qmctorch.utils import set_torch_double_precision
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
diff --git a/tests/wavefunction/pooling/test_trace_trick.py b/tests/wavefunction/pooling/test_trace_trick.py
index c97a9e87..5c7f874e 100644
--- a/tests/wavefunction/pooling/test_trace_trick.py
+++ b/tests/wavefunction/pooling/test_trace_trick.py
@@ -5,7 +5,7 @@
 from torch.autograd import Variable, grad
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
 
diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index 9522ff64..992a0c2a 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -3,7 +3,7 @@
 import unittest
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index 955b3569..e70762d7 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -3,7 +3,7 @@
 import unittest
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 65ae5f54..4597fb45 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -5,7 +5,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+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
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index d515743e..6d4c55f5 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -5,7 +5,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+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
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index d809ef23..d1f2e600 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -7,7 +7,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index faf4ea78..7f2ac909 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -5,7 +5,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index de6dcb25..7a40c1b8 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -5,7 +5,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index 8655a044..4dc1ffbc 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -4,7 +4,7 @@
 
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as SlaterJastrow
+from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
 from qmctorch.utils import set_torch_double_precision
 
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 90dd1ff0..66fbdacf 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -6,7 +6,7 @@
 
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 FullyConnectedJastrowKernel
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index f46cffdd..9072b9c5 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -7,7 +7,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_slaterjastrow_unified.py b/tests/wavefunction/test_slaterjastrow_unified.py
index d6fd01a7..e31a41c3 100644
--- a/tests/wavefunction/test_slaterjastrow_unified.py
+++ b/tests/wavefunction/test_slaterjastrow_unified.py
@@ -5,7 +5,7 @@
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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
diff --git a/tests/wavefunction/test_slaterjastrowgraph.py b/tests/wavefunction/test_slaterjastrowgraph.py
index ae217465..6f899ae4 100644
--- a/tests/wavefunction/test_slaterjastrowgraph.py
+++ b/tests/wavefunction/test_slaterjastrowgraph.py
@@ -1,7 +1,7 @@
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrowGraph
+from qmctorch.wavefunction import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+from qmctorch.wavefunction.jastrows.graph import JastrowFactor, MGCNPredictor
 
 from torch.autograd import grad, gradcheck, Variable
 
@@ -53,20 +53,23 @@ def setUp(self):
             basis='sto-3g',
             redo_scf=True)
 
-        self.wf = SlaterJastrowGraph(mol,
-                                     kinetic='auto',
-                                     include_all_mo=False,
-                                     configs='single_double(2,2)',
-                                     ee_model=MGCNPredictor,
-                                     ee_model_kwargs={'n_layers': 3,
-                                                      'feats': 32,
-                                                      'cutoff': 5.0,
-                                                      'gap': 1.},
-                                     en_model=MGCNPredictor,
-                                     en_model_kwargs={'n_layers': 3,
-                                                      'feats': 32,
-                                                      'cutoff': 5.0,
-                                                      'gap': 1.0})
+        # jastrow
+        jastrow = JastrowFactor(mol,
+                                ee_model=MGCNPredictor,
+                                ee_model_kwargs={'n_layers': 3,
+                                                 'feats': 32,
+                                                 'cutoff': 5.0,
+                                                 'gap': 1.},
+                                en_model=MGCNPredictor,
+                                en_model_kwargs={'n_layers': 3,
+                                                 'feats': 32,
+                                                 'cutoff': 5.0,
+                                                 'gap': 1.0})
+        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
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index ef63ddb3..56643ad5 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -9,7 +9,7 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrowHorovod
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow_unified import SlaterJastrowUnified as 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 3eb6965687745eccaaf49fb0cd90aebc014cf22f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 19 Aug 2021 15:25:06 +0200
Subject: [PATCH 058/286] change name of tests

---
 ...h.py => test_slater_mgcn_graph_jastrow.py} |  0
 .../test_slaterjastrow_unified.py             | 63 -------------------
 2 files changed, 63 deletions(-)
 rename tests/wavefunction/{test_slaterjastrowgraph.py => test_slater_mgcn_graph_jastrow.py} (100%)
 delete mode 100644 tests/wavefunction/test_slaterjastrow_unified.py

diff --git a/tests/wavefunction/test_slaterjastrowgraph.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
similarity index 100%
rename from tests/wavefunction/test_slaterjastrowgraph.py
rename to tests/wavefunction/test_slater_mgcn_graph_jastrow.py
diff --git a/tests/wavefunction/test_slaterjastrow_unified.py b/tests/wavefunction/test_slaterjastrow_unified.py
deleted file mode 100644
index e31a41c3..00000000
--- a/tests/wavefunction/test_slaterjastrow_unified.py
+++ /dev/null
@@ -1,63 +0,0 @@
-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.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
-
-
-torch.set_default_tensor_type(torch.DoubleTensor)
-
-
-class TestSlaterJastrow(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)
-
-        # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel)
-
-        # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
-
-        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.requires_grad = True
-
-
-if __name__ == "__main__":
-    unittest.main()

From e4b0a29b86de15b7905d5d24d285cd10801b2795 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Oct 2021 10:01:02 +0200
Subject: [PATCH 059/286] remove unused var

---
 qmctorch/wavefunction/pooling/slater_pooling.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 1d380f1b..3091d04c 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -437,12 +437,12 @@ def operator_unique_single_double(self, mo, bop, op_squared):
         mat_exc_up = (invAup @ Avirt_up)
         mat_exc_down = (invAdown @ Avirt_down)
 
-        bop_up = bop[..., :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_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]

From d76271513d6bb39f232a19439476ca5d5438edbf Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Oct 2021 17:24:09 +0200
Subject: [PATCH 060/286] made plot not autoload

---
 qmctorch/utils/__init__.py            | 22 ++++++++++++----------
 tests/solver/test_h2_pyscf_geo_opt.py |  8 ++++----
 tests/solver/test_h2_pyscf_stats.py   |  8 ++++----
 3 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 821f914a..67e0052b 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -5,11 +5,13 @@
                          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 .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, DataLoader, Loss, OrthoReg, fast_power,
@@ -17,11 +19,11 @@
                           set_torch_single_precision,
                           diagonal_hessian, gradients)
 
-__all__ = ['plot_energy', 'plot_data', 'plot_block',
-           'plot_walkers_traj',
-           'plot_correlation_time',
-           'plot_autocorrelation',
-           'set_torch_double_precision',
+# __all__ = ['plot_energy', 'plot_data', 'plot_block',
+#            'plot_walkers_traj',
+#            'plot_correlation_time',
+#            'plot_autocorrelation',
+__all__ = ['set_torch_double_precision',
            'set_torch_single_precision',
            'DataSet', 'Loss', 'OrthoReg', 'DataLoader',
            'dump_to_hdf5', 'load_from_hdf5',
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index cf70ba2b..efa3cfc1 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -7,10 +7,10 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
-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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index 25fe80ef..73094f10 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,10 +6,10 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
-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.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow

From 31fb635f1df4d992ae0278b8cc120e0562af7f80 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Oct 2021 17:27:03 +0200
Subject: [PATCH 061/286] remove plot load from slaterjastrow

---
 qmctorch/wavefunction/slater_jastrow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 59b06029..7611a1d9 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -3,7 +3,6 @@
 import torch
 from scipy.optimize import curve_fit
 from copy import deepcopy
-import matplotlib.pyplot as plt
 import numpy as np
 from torch import nn
 import operator
@@ -656,6 +655,7 @@ def sto(x, norm, alpha):
 
             # plot if necessary
             if plot:
+                import matplotlib.pyplot as plt
                 plt.plot(xdata, ydata)
                 plt.plot(xdata, sto(xdata, *popt))
                 plt.show()

From 0ba0d2e90bec86882590c688393d0aed7c2e2bf3 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Oct 2021 18:09:27 +0200
Subject: [PATCH 062/286] correct path to plot routine

---
 tests/solver/test_h2_pyscf_metropolis.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 2d9dea80..8b2c380f 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -9,10 +9,10 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.utils import (plot_block, plot_blocking_energy,
-                            plot_correlation_coefficient,
-                            plot_integrated_autocorrelation_time,
-                            plot_walkers_traj)
+from qmctorch.utils.plot_data, , 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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel

From 01e230a615cfdb3b01e12db348a0235e70384d42 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Oct 2021 22:46:25 +0200
Subject: [PATCH 063/286] remove unused import of plot routine

---
 tests/solver/test_h2_pyscf_metropolis.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 8b2c380f..ae1ad615 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -9,10 +9,7 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.utils.plot_data, , 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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel

From 148828f8d76113a3472496c28f425183d9ca3094 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 7 Oct 2021 10:37:45 +0200
Subject: [PATCH 064/286] fix import of plot data

---
 h5x/baseimport.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 9640e217..44339111 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,4 +1,4 @@
-from qmctorch.utils import (
+from qmctorch.utils.plot_data import (
     plot_energy, plot_data, plot_block, plot_walkers_traj)
 import matplotlib.pyplot as plt
 import numpy as np

From 37e2afd2069f8faf34adf746560688e12448084f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 11 Oct 2021 13:08:51 +0200
Subject: [PATCH 065/286] fixed batch energy

---
 example/optimization/h2.py     | 25 +++++++++++++++----------
 qmctorch/solver/solver_base.py | 13 ++++++++++---
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/example/optimization/h2.py b/example/optimization/h2.py
index dac6d569..e4ed7e3c 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -1,4 +1,5 @@
-
+import torch
+import numpy as np
 from torch import optim
 
 from qmctorch.scf import Molecule
@@ -6,7 +7,7 @@
 from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
+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
 
@@ -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',
@@ -32,11 +35,13 @@
                    jastrow=jastrow)
 
 # sampler
-sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
-                      step_size=0.1, L=30,
-                      ntherm=-1, ndecor=10,
-                      init=mol.domain('atomic'))
+# sampler = 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=100, nstep=100, nelec=wf.nelec,
+                     step_size=0.05, init=mol.domain('atomic'))
 
 # optimizer
 lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
@@ -53,7 +58,7 @@
                              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'], freeze=['ao', 'mo'],
@@ -64,8 +69,8 @@
                              'nstep_update': 50})
 
 # optimize the wave function
-obs = solver.run(250)
+obs = solver.run(5, batchsize=10)
 
 # plot
-plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname='jastrow.weight')
+# plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
+# plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 06fdbed2..9d4edba1 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,3 +1,4 @@
+from threading import local
 from types import SimpleNamespace
 import os
 import numpy as np
@@ -161,14 +162,20 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
         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)
+                        data).item()/(ibatch+1)
 
             # store local energy
             elif obs == 'local_energy' and local_energy is not None:

From 14b702c067b9bba04b139b87c5d74b7dddccc981 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 11 Oct 2021 17:40:35 +0200
Subject: [PATCH 066/286] remove sampler.walkers

---
 example/optimization/h2.py                 |  2 +-
 qmctorch/sampler/generalized_metropolis.py | 16 ++++++++--------
 qmctorch/sampler/metropolis.py             | 21 +++++++++++----------
 qmctorch/sampler/sampler_base.py           |  8 ++++----
 qmctorch/solver/solver_base.py             |  2 +-
 qmctorch/solver/solver_slater_jastrow.py   |  2 +-
 6 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/example/optimization/h2.py b/example/optimization/h2.py
index e4ed7e3c..b80ea43d 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -40,7 +40,7 @@
 #                       ntherm=-1, ndecor=10,
 #                       init=mol.domain('atomic'))
 
-sampler = Metropolis(nwalkers=100, nstep=100, nelec=wf.nelec,
+sampler = Metropolis(nwalkers=10, nstep=200, nelec=wf.nelec, ntherm=100, ndecor=10,
                      step_size=0.05, init=mol.domain('atomic'))
 
 # optimizer
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 93718884..3a2b53e7 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -84,7 +84,7 @@ 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, :]
@@ -117,17 +117,17 @@ def move(self, drift):
 
         # clone and reshape data : Nwlaker, Nelec, Ndim
         new_pos = self.walkers.pos.clone()
-        new_pos = new_pos.view(self.nwalkers,
+        new_pos = new_pos.view(self.walkers.nwalkers,
                                self.nelec, self.ndim)
 
         # get indexes
-        index = torch.LongTensor(self.nwalkers).random_(
+        index = torch.LongTensor(self.walkers.nwalkers).random_(
             0, self.nelec)
 
-        new_pos[range(self.nwalkers), index,
+        new_pos[range(self.walkers.nwalkers), index,
                 :] += self._move(drift, index)
 
-        return new_pos.view(self.nwalkers, self.nelec * self.ndim)
+        return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
     def _move(self, drift, index):
         """Move a walker.
@@ -140,14 +140,14 @@ def _move(self, drift, index):
             torch.tensor: position of the walkers
         """
 
-        d = drift.view(self.nwalkers,
+        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))
 
-        return self.step_size * d[range(self.nwalkers), index, :] \
-            + mv.sample((self.nwalkers, 1)).squeeze()
+        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
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index e40a9d89..7889bddb 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -141,7 +141,7 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
 
                     # acceptance rate
                     rate += index.byte().sum().float().to('cpu') / \
-                        (self.nwalkers * self._move_per_iter)
+                        (self.walkers.nwalkers * self._move_per_iter)
 
                     # update position/function value
                     self.walkers.pos[index, :] = Xn[index, :]
@@ -226,21 +226,22 @@ def move(self, pdf: Callable, id_elec: int) -> torch.Tensor:
 
             # clone and reshape data : Nwlaker, Nelec, Ndim
             new_pos = self.walkers.pos.clone()
-            new_pos = new_pos.view(self.nwalkers,
+            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_(
+                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,
+            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
@@ -253,15 +254,15 @@ def _move(self, num_elec: int) -> torch.Tensor:
         """
         if self.movedict['proba'] == 'uniform':
             d = torch.rand(
-                (self.nwalkers, num_elec, self.ndim), device=self.device).view(
-                self.nwalkers, num_elec * self.ndim)
+                (self.walkers.nwalkers, num_elec, self.ndim), device=self.device).view(
+                self.walkers.nwalkers, num_elec * self.ndim)
             return self.step_size * (2. * d - 1.)
 
         elif self.movedict['proba'] == 'normal':
             displacement = self.multiVariate.sample(
-                (self.nwalkers, num_elec)).to(self.device)
+                (self.walkers.nwalkers, num_elec)).to(self.device)
             return displacement.view(
-                self.nwalkers, num_elec * self.ndim)
+                self.walkers.nwalkers, num_elec * self.ndim)
 
     def _accept(self, proba: torch.Tensor) -> torch.Tensor:
         """accept the move or not
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index 9dbaf420..b3be0870 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -23,7 +23,7 @@ def __init__(self, nwalkers, nstep, step_size,
             cuda ([type]): [description]
         """
 
-        self.nwalkers = nwalkers
+        # self.nwalkers = nwalkers
         self.nelec = nelec
         self.ndim = ndim
         self.nstep = nstep
@@ -41,7 +41,7 @@ def __init__(self, nwalkers, nstep, step_size,
 
         log.info('')
         log.info(' Monte-Carlo Sampler')
-        log.info('  Number of walkers   : {0}', self.nwalkers)
+        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)
@@ -53,11 +53,11 @@ def __call__(self, pdf, *args, **kwargs):
             "Sampler must have a __call__ method")
 
     def __repr__(self):
-        return self.__class__.__name__ + ' sampler with  %d walkers' % self.nwalkers
+        return self.__class__.__name__ + ' sampler with  %d walkers' % self.walkers.nwalkers
 
     def get_sampling_size(self):
         """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)
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 9d4edba1..81cd324d 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -268,7 +268,7 @@ def resample(self, n, pos):
 
                 # sample and update the dataset
                 pos = self.sampler(
-                    self.wf.pdf, pos=pos, with_tqdm=False)
+                    self.wf.pdf, pos=pos, with_tqdm=True)
                 self.dataloader.dataset = pos
 
             # update the weight of the loss if needed
diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index ce8f71e0..12500a27 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -259,7 +259,7 @@ def run(self, nepoch, batchsize=None,
 
         return self.observable
 
-    def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
+    def prepare_optimization(self, batchsize, chkpt_every, tqdm=True):
         """Prepare the optimization process
 
         Args:

From 8a654aa4a6012e6c72088b773d85e740c54414d0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 11 Oct 2021 18:33:58 +0200
Subject: [PATCH 067/286] use only nwalkers even in resampling and increase the
 numner of points

---
 example/optimization/h2.py                    |  4 ++-
 qmctorch/solver/solver_base.py                | 27 ++++++++++++++++---
 qmctorch/solver/solver_slater_jastrow.py      | 12 ++++-----
 .../solver/solver_slater_jastrow_horovod.py   |  7 ++---
 4 files changed, 33 insertions(+), 17 deletions(-)

diff --git a/example/optimization/h2.py b/example/optimization/h2.py
index b80ea43d..1ad043ff 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -66,7 +66,9 @@
                  ortho_mo=False, clip_loss=False,
                  resampling={'mode': 'update',
                              'resample_every': 1,
-                             'nstep_update': 50})
+                             'nstep_update': 200,
+                             'ntherm_update': 50}
+                 )
 
 # optimize the wave function
 obs = solver.run(5, batchsize=10)
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 81cd324d..863aef8b 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -3,6 +3,7 @@
 import os
 import numpy as np
 import torch
+from torch._C import Value
 from tqdm import tqdm
 
 from .. import log
@@ -63,7 +64,8 @@ def __init__(self, wf=None, sampler=None,
 
         self.log_data()
 
-    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25):
+    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25, ntherm_update=-1,
+                             increment={'every': None, 'factor': None}):
         """Configure the resampling
 
         Args:
@@ -73,6 +75,12 @@ def configure_resampling(self, mode='update', resample_every=1, nstep_update=25)
                                  Defaults to 1.
             nstep_update (int, optional): Number of MC steps in update mode.
                                           Defaults to 25.
+            ntherm_update (int, optional): 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()
@@ -83,7 +91,9 @@ def configure_resampling(self, mode='update', resample_every=1, nstep_update=25)
 
         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):
         """define the observalbe we want to track
@@ -260,15 +270,24 @@ def resample(self, n, pos):
 
                 # make a copy of the pos if we update
                 if self.resampling_options.mode == 'update':
-                    pos = pos.clone().detach().to(self.device)
+                    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=True)
+                print(self.sampler.walkers.nwalkers)
+                print(pos.shape)
                 self.dataloader.dataset = pos
 
             # update the weight of the loss if needed
@@ -291,7 +310,7 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
 
         log.info('')
         log.info('  Single Point Calculation : {nw} walkers | {ns} steps',
-                 nw=self.sampler.nwalkers, ns=self.sampler.nstep)
+                 nw=self.sampler.walkers.nwalkers, ns=self.sampler.nstep)
 
         # check if we have to compute and store the grads
         grad_mode = torch.no_grad()
@@ -394,7 +413,7 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group='sampling_trajector
             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)
diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 12500a27..408f9bc8 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -140,20 +140,18 @@ def save_sampling_parameters(self, pos):
         """ 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
+            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):
         """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
+        # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
     def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
                 nepoch_wf_init=100, nepoch_wf_update=50,
@@ -386,7 +384,7 @@ def evaluate_grad_auto(self, lpos):
             loss += self.ortho_loss(self.wf.mo.weight)
 
         # compute local gradients
-        # self.opt.zero_grad()
+        # self.opt.zero_grad() ???
         loss.backward()
 
         return loss, eloc
diff --git a/qmctorch/solver/solver_slater_jastrow_horovod.py b/qmctorch/solver/solver_slater_jastrow_horovod.py
index bb6a9226..6bdad594 100644
--- a/qmctorch/solver/solver_slater_jastrow_horovod.py
+++ b/qmctorch/solver/solver_slater_jastrow_horovod.py
@@ -41,7 +41,6 @@ def __init__(self, wf=None, sampler=None, optimizer=None,
         self.opt = hvd.DistributedOptimizer(
             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',
@@ -68,7 +67,7 @@ def run(self, nepoch, batchsize=None, loss='energy',
         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))
+                 id=hvd.rank(), nw=self.sampler.walkers.nwalkers))
 
         # observable
         if not hasattr(self, 'observable'):
@@ -124,7 +123,6 @@ def run(self, nepoch, batchsize=None, loss='energy',
             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)
@@ -188,7 +186,6 @@ def run(self, nepoch, batchsize=None, loss='energy',
         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)
@@ -210,7 +207,7 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
 
         logd(hvd.rank(), '')
         logd(hvd.rank(), '  Single Point Calculation : {nw} walkers | {ns} steps'.format(
-             nw=self.sampler.nwalkers, ns=self.sampler.nstep))
+             nw=self.sampler.walkers.nwalkers, ns=self.sampler.nstep))
 
         # check if we have to compute and store the grads
         grad_mode = torch.no_grad()

From 234284cef84f549d24210319e65e6ed948d78803 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 11 Oct 2021 21:40:37 +0200
Subject: [PATCH 068/286] print number sampking points

---
 example/optimization/h2.py               | 4 ++--
 qmctorch/solver/solver_base.py           | 5 ++---
 qmctorch/solver/solver_slater_jastrow.py | 5 +++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/example/optimization/h2.py b/example/optimization/h2.py
index 1ad043ff..18880f2f 100644
--- a/example/optimization/h2.py
+++ b/example/optimization/h2.py
@@ -66,12 +66,12 @@
                  ortho_mo=False, clip_loss=False,
                  resampling={'mode': 'update',
                              'resample_every': 1,
-                             'nstep_update': 200,
+                             'nstep_update': 150,
                              'ntherm_update': 50}
                  )
 
 # optimize the wave function
-obs = solver.run(5, batchsize=10)
+obs = solver.run(5)  # , batchsize=10)
 
 # plot
 # plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 863aef8b..8a0def2f 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -285,9 +285,8 @@ def resample(self, n, pos):
 
                 # sample and update the dataset
                 pos = self.sampler(
-                    self.wf.pdf, pos=pos, with_tqdm=True)
-                print(self.sampler.walkers.nwalkers)
-                print(pos.shape)
+                    self.wf.pdf, pos=pos, with_tqdm=False)
+
                 self.dataloader.dataset = pos
 
             # update the weight of the loss if needed
diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 408f9bc8..3c51f5cb 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -257,7 +257,7 @@ def run(self, nepoch, batchsize=None,
 
         return self.observable
 
-    def prepare_optimization(self, batchsize, chkpt_every, tqdm=True):
+    def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         """Prepare the optimization process
 
         Args:
@@ -313,7 +313,8 @@ def run_epochs(self, nepoch):
 
             tstart = time()
             log.info('')
-            log.info('  epoch %d' % n)
+            log.info('  epoch %d | %d sampling points' %
+                     (n, len(self.dataloader.dataset)))
 
             cumulative_loss = 0
 

From 6477409cb40ada895c8c2df1a745cd8e1d6376f8 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 14 Oct 2021 09:46:02 +0200
Subject: [PATCH 069/286] fix issue with reweighting sampling points

---
 qmctorch/utils/torch_utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 04dc8ce4..12eeaf7a 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -236,7 +236,7 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
             mask = self.get_clipping_mask(local_energies)
 
             # sampling_weight
-            weight = self.get_sampling_weights(deactivate_weight)
+            weight = self.get_sampling_weights(pos, deactivate_weight)
 
             # compute the loss
             loss = self.loss_fn((weight * local_energies)[mask])
@@ -273,7 +273,7 @@ def get_clipping_mask(self, local_energies):
 
         return mask
 
-    def get_sampling_weights(self, deactivate_weight):
+    def get_sampling_weights(self, pos, deactivate_weight):
         """Get the weight needed when resampling is not
             done at every step
         """

From 47acadcb156f1856183df5d446b601ddd2417d8f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 18 Oct 2021 19:02:18 +0200
Subject: [PATCH 070/286] batch single point

---
 qmctorch/solver/solver_base.py | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 8a0def2f..b67efac5 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -295,7 +295,7 @@ def resample(self, n, pos):
 
         return pos
 
-    def single_point(self, with_tqdm=True, hdf5_group='single_point'):
+    def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'):
         """Performs a single point calculatin
 
         Args:
@@ -325,9 +325,24 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
                 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(
@@ -338,7 +353,7 @@ def single_point(self, with_tqdm=True, hdf5_group='single_point'):
             # dump data to hdf5
             obs = SimpleNamespace(
                 pos=pos,
-                local_energy=el,
+                local_energy=eloc,
                 energy=e,
                 variance=s,
                 error=err

From c739ba2723d6e23f61b857517abe1a6ec04ac103 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 18 Oct 2021 19:02:55 +0200
Subject: [PATCH 071/286] grey value

---
 qmctorch/utils/plot_data.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 1ef0426e..0d3868e9 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -92,7 +92,8 @@ def plot_walkers_traj(eloc, walkers='mean'):
         # plt.subplot(1, 2, 1)
 
         if walkers == 'all':
-            plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
+            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])
@@ -103,7 +104,7 @@ def plot_walkers_traj(eloc, walkers='mean'):
 
         else:
             plt.plot(eloc[walkers, :], 'o',
-                     alpha=1 / nwalkers, c='grey')
+                     alpha=max(1 / nwalkers, 1E-2), c='grey')
             plt.plot(celoc.T[traj_index, :])
         plt.grid()
         plt.xlabel('Monte Carlo Steps')

From 0ef9ea6255874fb3efb4d211d61b356c5a6948a8 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 18 Oct 2021 19:03:10 +0200
Subject: [PATCH 072/286] added simple metropolis

---
 qmctorch/sampler/metropolis_all_elec.py | 222 ++++++++++++++++++++++++
 1 file changed, 222 insertions(+)
 create mode 100644 qmctorch/sampler/metropolis_all_elec.py

diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
new file mode 100644
index 00000000..851f1b84
--- /dev/null
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -0,0 +1,222 @@
+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.))))
+            self.multiVariate = MultivariateNormal(
+                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim))
+
+        self.log_data()
+
+    def log_data(self):
+        """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):
+        """Compute the negative log of  a function
+
+        Args:
+            func (callable): input function
+
+        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:
+            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).view(
+                self.walkers.nwalkers, num_elec * self.ndim)
+            return self.step_size * (2. * d - 1.)
+
+        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)

From 7705e1aa845a88969db23bdce805813d70b4f17f Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 19 Oct 2021 17:46:23 +0200
Subject: [PATCH 073/286] jastrow cobined term kernels as modulelist

---
 qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index 60b4e642..6db28ce9 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -40,7 +40,7 @@ def __init__(self, mol,
         self.ndown = mol.ndown
         self.cuda = cuda
         self.jastrow_kernel_dict = jastrow_kernel
-        self.jastrow_terms = []
+        self.jastrow_terms = nn.ModuleList()
 
         # sanitize the dict
         for k in ['ee', 'en', 'een']:

From 9c1859dfab19da6628213851b678120bd9bcb1ab Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 20 Oct 2021 10:36:57 +0200
Subject: [PATCH 074/286] added energy plotter bin

---
 bin/qmctorch_energy_plotter | 54 +++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100755 bin/qmctorch_energy_plotter

diff --git a/bin/qmctorch_energy_plotter b/bin/qmctorch_energy_plotter
new file mode 100755
index 00000000..b4b4d7e2
--- /dev/null
+++ b/bin/qmctorch_energy_plotter
@@ -0,0 +1,54 @@
+#!/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]
+        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)

From afa39b0743c8aa44e5b4460561f0fd54b8d83a30 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 20 Oct 2021 12:36:08 +0200
Subject: [PATCH 075/286] simplified combining jastrows

---
 bin/qmctorch_energy_plotter                   |   1 +
 .../wavefunction/jastrows/combine_jastrow.py  | 168 ++++++++++++++++++
 qmctorch/wavefunction/slater_jastrow.py       |  17 +-
 .../test_slatercombinedjastrow_internal.py    |  57 ++++++
 4 files changed, 239 insertions(+), 4 deletions(-)
 create mode 100644 qmctorch/wavefunction/jastrows/combine_jastrow.py
 create mode 100644 tests/wavefunction/test_slatercombinedjastrow_internal.py

diff --git a/bin/qmctorch_energy_plotter b/bin/qmctorch_energy_plotter
index b4b4d7e2..2d431d9e 100755
--- a/bin/qmctorch_energy_plotter
+++ b/bin/qmctorch_energy_plotter
@@ -21,6 +21,7 @@ def plot_percent_correlation_energy(args):
     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))
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
new file mode 100644
index 00000000..90bac67e
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -0,0 +1,168 @@
+
+import torch
+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.
+            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]
+        else:
+            out = 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.*reduce(lambda x, y: x*y, tmp)).sum(1)
+
+            return out
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 7611a1d9..fc4b9123 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -10,6 +10,7 @@
 from .. import log
 
 from .wf_base import WaveFunction
+from .jastrows.combine_jastrow import CombineJastrow
 from .orbitals.atomic_orbitals import AtomicOrbitals
 from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
 from .pooling.slater_pooling import SlaterPooling
@@ -169,18 +170,26 @@ def init_fc_layer(self):
     def init_jastrow(self, jastrow):
         """Init the jastrow factor calculator"""
 
-        self.jastrow = jastrow
-
-        if self.jastrow is None:
+        if jastrow is None:
+            self.jastrow = jastrow
             self.use_jastrow = False
 
         else:
             self.use_jastrow = True
-            self.jastrow_type = self.jastrow.__repr__()
 
+            if isinstance(jastrow, list):
+                self.jastrow = CombineJastrow(jastrow)
+            else:
+                self.jastrow = jastrow
+
+            self.jastrow_type = self.jastrow.__repr__()
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
 
+    def set_combined_jastrow(self, jastrow):
+        """Initialize the jastrow factor as a sum of jastrows"""
+        self.jastrow = CombineJastrow(jastrow)
+
     def init_kinetic(self, kinetic, backflow):
         """"Init the calculator of the kinetic energies"""
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_internal.py b/tests/wavefunction/test_slatercombinedjastrow_internal.py
new file mode 100644
index 00000000..861cc674
--- /dev/null
+++ b/tests/wavefunction/test_slatercombinedjastrow_internal.py
@@ -0,0 +1,57 @@
+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()

From b7db7e1c5f8e7d03f8ae677120f2e40e5def2b18 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 20 Oct 2021 21:39:19 +0200
Subject: [PATCH 076/286] added possiblity to have odd number of elec

---
 qmctorch/scf/calculator/adf.py                | 11 ++++-
 qmctorch/scf/calculator/calculator_base.py    |  4 +-
 qmctorch/scf/calculator/pyscf.py              |  6 ++-
 qmctorch/scf/molecule.py                      | 20 +++++++--
 .../pooling/orbital_configurations.py         | 42 ++++++++++++++-----
 qmctorch/wavefunction/slater_jastrow.py       |  3 +-
 6 files changed, 66 insertions(+), 20 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index cccd21d8..e69798b4 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -16,10 +16,10 @@
 
 class CalculatorADF(CalculatorBase):
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
 
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, 'adf', savefile)
+            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'adf', savefile)
 
         # basis from the emma paper
         self.additional_basis_type = ['VB1', 'VB2', 'VB3',
@@ -93,6 +93,13 @@ def get_plams_settings(self):
         # total energy
         sett.input.totalenergy = True
 
+        # charge info
+        sett.input.charge = self.charge
+
+        # spin info
+        sett.input.unrestricted = False
+        sett.input.spinpolarization = self.spin
+
         return sett
 
     def get_basis_data(self, kffile):
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index 2dd1b3eb..4eea3fc6 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -4,11 +4,13 @@
 
 
 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
diff --git a/qmctorch/scf/calculator/pyscf.py b/qmctorch/scf/calculator/pyscf.py
index b3b75c28..be41387a 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -8,10 +8,10 @@
 
 class CalculatorPySCF(CalculatorBase):
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
 
         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):
         """Run the scf calculation using PySCF."""
@@ -22,6 +22,8 @@ def run(self):
         # pyscf calculation
         mol = gto.M(
             atom=atom_str,
+            spin=self.spin,
+            charge=self.charge,
             basis=self.basis_name,
             unit=self.units,
             cart=False)
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index dc58f3fc..72d6f771 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -21,14 +21,18 @@ class Molecule:
 
     def __init__(self, atom=None, calculator='adf',
                  scf='hf', basis='dzp', unit='bohr',
+                 charge=0, spin=0,
                  name=None, load=None, save_scf_file=False,
                  redo_scf=False, rank=0, mpi_size=0):
         """Create a molecule in QMCTorch
 
         Args:
             atom (str or None, optional): defines the atoms and their positions. Defaults to None.
+            spin (int): Nup-Ndown electrons
             calculator (str, optional): selet scf calculator. Defaults to 'adf'.
             scf (str, optional): select scf level of theory. Defaults to 'hf'.
+            charge (int, optional): extra charge on the molecule, Default to 0
+            spin (int, optional): exess of spin up electrons on the molecule, Default to 0
             basis (str, optional): select the basis set. Defaults to 'dzp'.
             unit (str, optional): units of the coordinates. Defaults to 'bohr'.
             name (str or None, optional): name of the molecule. Defaults to None.
@@ -56,6 +60,8 @@ def __init__(self, atom=None, calculator='adf',
         self.ndown = 0
         self.nelec = 0
         self.nup = 0
+        self.charge = charge
+        self.spin = spin
         self.unit = unit
         self.basis = SimpleNamespace()
         self.calculator_name = calculator
@@ -110,6 +116,8 @@ def __init__(self, atom=None, calculator='adf',
                     self.calculator = calc(self.atoms,
                                            self.atom_coords,
                                            basis,
+                                           self.charge,
+                                           self.spin,
                                            self.scf_level,
                                            self.unit,
                                            self.name,
@@ -228,12 +236,16 @@ def _get_atomic_properties(self, atoms):
             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:
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 0cc8c857..95660a0c 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -4,10 +4,11 @@
 class OrbitalConfigurations:
 
     def __init__(self, mol):
-        # self.mol = mol
+
         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):
@@ -103,15 +104,26 @@ def _get_single_config(self, nocc, nvirt):
         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):
+                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)
 
+        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)
 
@@ -132,12 +144,13 @@ def _get_single_double_config(self, nocc, nvirt):
         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))
+            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))
+            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:
@@ -183,6 +196,9 @@ def _get_cas_config(self, nocc, nvirt, nelec):
             nvirt ([type]): number of virt orbitals in the CAS
         """
         from itertools import combinations, product
+        if self.spin != 0:
+            raise ValueError(
+                'CAS active space not possible with spin polarized calculation')
 
         idx_low, idx_high = self.nup - nocc, self.nup + nvirt
         orb_index_up = range(idx_low, idx_high)
@@ -215,11 +231,17 @@ 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):
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index fc4b9123..c71d7a05 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -144,7 +144,8 @@ def init_config(self, configs):
         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
+        self.highest_occ_mo = max(
+            self.configs[0].max(), self.configs[1].max())+1
 
     def init_slater_det_calculator(self):
         """Initialize the calculator of the slater dets"""

From 67ad02f3ea20a1304ffa49c438fd073028d57bd8 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 20 Oct 2021 22:36:15 +0200
Subject: [PATCH 077/286] fixed orb conf cas

---
 qmctorch/wavefunction/pooling/orbital_configurations.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 95660a0c..c0d3aa9e 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -200,13 +200,14 @@ def _get_cas_config(self, nocc, nvirt, nelec):
             raise ValueError(
                 'CAS active space not possible with spin polarized calculation')
 
-        idx_low, idx_high = self.nup - nocc, self.nup + nvirt
+        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))]
 
-        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 +

From 307f85767f7e1fa2c35db10c3830f832d35a6624 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 21 Oct 2021 09:00:02 +0200
Subject: [PATCH 078/286] charge and spin info correct in plamms

---
 qmctorch/scf/calculator/adf.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index e69798b4..ae4ebbe1 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -51,7 +51,7 @@ def run(self):
         if self.savefile:
             shutil.copyfile(t21_path, t21_name)
             self.savefile = t21_name
-        shutil.rmtree(plams_wd)
+        # shutil.rmtree(plams_wd)
 
         return basis
 
@@ -94,11 +94,11 @@ def get_plams_settings(self):
         sett.input.totalenergy = True
 
         # charge info
-        sett.input.charge = self.charge
+        sett.input.charge = "%d %d" % (self.charge, self.spin)
 
         # spin info
         sett.input.unrestricted = False
-        sett.input.spinpolarization = self.spin
+        # sett.input.spinpolarization = self.spin
 
         return sett
 

From eca74648138b7d03fe757b1e53da4d56bb6d3644 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 21 Oct 2021 13:29:16 +0200
Subject: [PATCH 079/286] fix dump of tuple of torch tensors

---
 qmctorch/utils/hdf5_utils.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 1450c92b..9a5dfd75 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -308,6 +308,9 @@ 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.numpy() if isinstance(
+        o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 

From 475308181cb93be96346f8670eec9c237d30f1ab Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 21 Oct 2021 16:27:42 +0200
Subject: [PATCH 080/286] added pints interface to samplers

---
 qmctorch/sampler/metropolis_all_elec.py |   3 +-
 qmctorch/sampler/pints_sampler.py       | 140 ++++++++++++++++++++++++
 qmctorch/utils/plot_data.py             |   2 +-
 3 files changed, 142 insertions(+), 3 deletions(-)
 create mode 100644 qmctorch/sampler/pints_sampler.py

diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 851f1b84..1a81e923 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -191,8 +191,7 @@ def _move(self, num_elec: int) -> torch.Tensor:
         """
         if self.movedict['proba'] == 'uniform':
             d = torch.rand(
-                (self.walkers.nwalkers, num_elec, self.ndim), device=self.device).view(
-                self.walkers.nwalkers, num_elec * self.ndim)
+                (self.walkers.nwalkers, num_elec*self.ndim), device=self.device)
             return self.step_size * (2. * d - 1.)
 
         elif self.movedict['proba'] == 'normal':
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
new file mode 100644
index 00000000..e981a1fd
--- /dev/null
+++ b/qmctorch/sampler/pints_sampler.py
@@ -0,0 +1,140 @@
+from tqdm import tqdm
+import torch
+import pints
+from typing import Callable, Union, Dict
+from .sampler_base import SamplerBase
+from .. import log
+
+
+class torch_model(pints.LogPDF):
+
+    def __init__(self, pdf, ndim):
+        self.pdf = pdf
+        self.ndim = ndim
+
+    def __call__(self, x):
+        x = torch.as_tensor(x).view(1, -1)
+        return torch.log(self.pdf(x)).cpu().detach().numpy()
+
+    def evaluateS1(self, x):
+        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./pdf * self.pdf(x, return_grad=True)
+        return (log_pdf.cpu().detach().numpy(), grad_log_pdf.cpu().detach().numpy())
+
+    def n_parameters(self):
+        return self.ndim
+
+
+class PintsSampler(SamplerBase):
+
+    def __init__(self,
+                 nwalkers: int = 100,
+                 method=pints.MetropolisRandomWalkMCMC,
+                 method_requires_grad=False,
+                 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},
+                 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.method = method
+        self.method_requires_grad = method_requires_grad
+        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):
+        """Compute the negative log of  a function
+
+        Args:
+            func (callable): input function
+
+        Returns:
+            callable: 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, method=self.method)
+            mcmc.set_max_iterations(self.nstep)
+            mcmc._log_to_screen = True
+            # mcmc._message_interval = 1000
+            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/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 0d3868e9..552cc832 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -99,7 +99,7 @@ def plot_walkers_traj(eloc, walkers='mean'):
                 plt.plot(celoc.T[:, i], color=cmap[i])
 
         elif walkers == 'mean':
-            plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
+            # plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
             plt.plot(np.mean(celoc.T, axis=1), linewidth=5)
 
         else:

From 7256d139bc16112982379b5612fa935e6cf4633e Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Tue, 26 Oct 2021 22:58:10 +0200
Subject: [PATCH 081/286] added metropolis hasting with assymetric proposal

---
 .../sampler/metropolis_hasting_all_elec.py    | 263 ++++++++++++++++++
 1 file changed, 263 insertions(+)
 create mode 100644 qmctorch/sampler/metropolis_hasting_all_elec.py

diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
new file mode 100644
index 00000000..3cff1af9
--- /dev/null
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -0,0 +1,263 @@
+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 DensityVarianceKernel(object):
+
+    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
+        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. - 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(object):
+
+    def __init__(self, sigma=1., scale_factor=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. - 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(object):
+    def __init__(self, sigma=0.2):
+        self.sigma = sigma
+
+    def __call__(self, x):
+        return self.sigma
+
+
+class StateDependentNormalProposal(object):
+
+    def __init__(self, kernel, nelec, ndim, device):
+
+        self.ndim = ndim
+        self.nelec = nelec
+        self.kernel = kernel
+        self.device = device
+        self.multiVariate = MultivariateNormal(
+            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
+
+    def __call__(self, x):
+        nwalkers = x.shape[0]
+        scale = self.kernel(x)
+        displacement = self.multiVariate.sample(
+            (nwalkers, self.nelec)).to(self.device)
+        displacement *= scale
+        return displacement.view(nwalkers, self.nelec*self.ndim)
+
+    def get_transition_ratio(self, x, y):
+        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./sigmay-1./sigmax))
+        tratio *= prefac
+
+        return tratio.squeeze().prod(-1)
+
+
+class MetropolisHasting(SamplerBase):
+
+    def __init__(self,
+                 kernel=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):
+        """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,
+                             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):
+        """log data about the sampler."""
+        # log.info('  Move type           : {0}', 'all-elec')
+
+    @staticmethod
+    def log_func(func):
+        """Compute the negative log of  a function
+
+        Args:
+            func (callable): input function
+
+        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:
+            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)

From 9c2cfc7a52368d52ab310404b06875a25a8ef01b Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 27 Oct 2021 12:58:01 +0200
Subject: [PATCH 082/286] added test for pints sampler

---
 tests/sampler/test_pints.py | 40 +++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 tests/sampler/test_pints.py

diff --git a/tests/sampler/test_pints.py b/tests/sampler/test_pints.py
new file mode 100644
index 00000000..7a85026d
--- /dev/null
+++ b/tests/sampler/test_pints.py
@@ -0,0 +1,40 @@
+import unittest
+
+
+import pints
+from qmctorch.sampler import PintsSampler
+from .test_sampler_base import TestSamplerBase
+
+
+class TestMetropolis(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()

From 72246082b10d11c0c09f8856cd434f26b7194937 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 27 Oct 2021 13:12:44 +0200
Subject: [PATCH 083/286] added mh with assymetric distribution

---
 .../sampler/metropolis_hasting_all_elec.py    | 92 +------------------
 qmctorch/sampler/proposal_kernels.py          | 63 +++++++++++++
 .../state_dependent_normal_proposal.py        | 41 +++++++++
 3 files changed, 106 insertions(+), 90 deletions(-)
 create mode 100644 qmctorch/sampler/proposal_kernels.py
 create mode 100644 qmctorch/sampler/state_dependent_normal_proposal.py

diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index 3cff1af9..1934e877 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -1,100 +1,12 @@
 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 DensityVarianceKernel(object):
-
-    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
-        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. - 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(object):
-
-    def __init__(self, sigma=1., scale_factor=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. - 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(object):
-    def __init__(self, sigma=0.2):
-        self.sigma = sigma
-
-    def __call__(self, x):
-        return self.sigma
-
-
-class StateDependentNormalProposal(object):
-
-    def __init__(self, kernel, nelec, ndim, device):
-
-        self.ndim = ndim
-        self.nelec = nelec
-        self.kernel = kernel
-        self.device = device
-        self.multiVariate = MultivariateNormal(
-            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
-
-    def __call__(self, x):
-        nwalkers = x.shape[0]
-        scale = self.kernel(x)
-        displacement = self.multiVariate.sample(
-            (nwalkers, self.nelec)).to(self.device)
-        displacement *= scale
-        return displacement.view(nwalkers, self.nelec*self.ndim)
-
-    def get_transition_ratio(self, x, y):
-        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./sigmay-1./sigmax))
-        tratio *= prefac
-
-        return tratio.squeeze().prod(-1)
+from .proposal_kernels import ConstantVarianceKernel
+from .state_dependent_normal_proposal import StateDependentNormalProposal
 
 
 class MetropolisHasting(SamplerBase):
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
new file mode 100644
index 00000000..fd96a120
--- /dev/null
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -0,0 +1,63 @@
+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 DensityVarianceKernel(object):
+
+    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
+        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. - 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(object):
+
+    def __init__(self, sigma=1., scale_factor=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. - 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(object):
+    def __init__(self, sigma=0.2):
+        self.sigma = sigma
+
+    def __call__(self, x):
+        return self.sigma
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
new file mode 100644
index 00000000..941a9640
--- /dev/null
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -0,0 +1,41 @@
+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 StateDependentNormalProposal(object):
+
+    def __init__(self, kernel, nelec, ndim, device):
+
+        self.ndim = ndim
+        self.nelec = nelec
+        self.kernel = kernel
+        self.device = device
+        self.multiVariate = MultivariateNormal(
+            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
+
+    def __call__(self, x):
+        nwalkers = x.shape[0]
+        scale = self.kernel(x)
+        displacement = self.multiVariate.sample(
+            (nwalkers, self.nelec)).to(self.device)
+        displacement *= scale
+        return displacement.view(nwalkers, self.nelec*self.ndim)
+
+    def get_transition_ratio(self, x, y):
+        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./sigmay-1./sigmax))
+        tratio *= prefac
+
+        return tratio.squeeze().prod(-1)

From f59ea34594b6bbfa8ffd283e282828776a054ca3 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 27 Oct 2021 13:13:05 +0200
Subject: [PATCH 084/286] added pints to setup

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index c0f6d2c6..7a8d71a4 100644
--- a/setup.py
+++ b/setup.py
@@ -42,7 +42,7 @@
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
                       'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
-                      'plams',
+                      'plams', 'pints',
                       'pyscf', 'mendeleev', 'twiggy'],
 
     extras_require={

From c1c42b83e1a906a71b11f74ffe1bd0c172a838f0 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Wed, 27 Oct 2021 13:20:55 +0200
Subject: [PATCH 085/286] added test for mh

---
 qmctorch/sampler/__init__.py             |  4 ++
 qmctorch/sampler/pints_sampler.py        | 48 ++++++++++++++++++------
 tests/sampler/test_metropolis_hasting.py | 37 ++++++++++++++++++
 tests/sampler/test_pints.py              |  2 +-
 4 files changed, 79 insertions(+), 12 deletions(-)
 create mode 100644 tests/sampler/test_metropolis_hasting.py

diff --git a/qmctorch/sampler/__init__.py b/qmctorch/sampler/__init__.py
index cc322b98..8b135be4 100644
--- a/qmctorch/sampler/__init__.py
+++ b/qmctorch/sampler/__init__.py
@@ -2,9 +2,13 @@
     '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/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index e981a1fd..fc923f8f 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -9,16 +9,38 @@
 class torch_model(pints.LogPDF):
 
     def __init__(self, pdf, ndim):
+        """Ancillary class tha wrap the wave function in a PINTS class
+
+        Args:
+            pdf (callable): wf.pdf function
+            ndim (int): number of dimensions
+        """
         self.pdf = pdf
         self.ndim = ndim
 
     def __call__(self, x):
+        """Evalaute the log pdf of the wave function at points x
+
+        Args:
+            x (numpy array): positions of the walkers
+
+        Returns:
+            numpy.array: values of the log pdfat those points
+        """
         x = torch.as_tensor(x).view(1, -1)
         return torch.log(self.pdf(x)).cpu().detach().numpy()
 
     def evaluateS1(self, x):
-        x = torch.as_tensor(x).view(1, -1)
+        """Evalaute the log pdf and the gradients of the log pdf at points x
+
+        Args:
+            x (numpy.array): positions of the walkers
 
+        Returns:
+            tuple: values of the log pdf and gradients
+        """
+
+        x = torch.as_tensor(x).view(1, -1)
         pdf = self.pdf(x)
         log_pdf = torch.log(pdf)
         x.requires_grad = True
@@ -26,6 +48,7 @@ def evaluateS1(self, x):
         return (log_pdf.cpu().detach().numpy(), grad_log_pdf.cpu().detach().numpy())
 
     def n_parameters(self):
+        """Returns the number of dimensions."""
         return self.ndim
 
 
@@ -36,14 +59,15 @@ def __init__(self,
                  method=pints.MetropolisRandomWalkMCMC,
                  method_requires_grad=False,
                  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},
-                 cuda: bool = False):
-        """Metropolis Hasting generator
+                 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.
@@ -73,18 +97,20 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             step_size, ntherm, ndecor,
+        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))
+        # log.info(
+        #     '  Sampler             : {0}', self.method.name(None))
 
     @staticmethod
     def log_func(func):
@@ -129,10 +155,10 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             log_pdf = torch_model(pdf, self.walkers.pos.shape[1])
 
             mcmc = pints.MCMCController(
-                log_pdf, self.walkers.nwalkers, self.walkers.pos, method=self.method)
+                log_pdf, self.walkers.nwalkers, self.walkers.pos.cpu(), method=self.method)
             mcmc.set_max_iterations(self.nstep)
-            mcmc._log_to_screen = True
-            # mcmc._message_interval = 1000
+            mcmc._log_to_screen = self.log_to_screen
+            mcmc._message_interval = self.message_interval
             chains = mcmc.run()
 
         chains = chains[:, self.ntherm::self.ndecor, :]
diff --git a/tests/sampler/test_metropolis_hasting.py b/tests/sampler/test_metropolis_hasting.py
new file mode 100644
index 00000000..f8a1c007
--- /dev/null
+++ b/tests/sampler/test_metropolis_hasting.py
@@ -0,0 +1,37 @@
+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
index 7a85026d..a4c2674e 100644
--- a/tests/sampler/test_pints.py
+++ b/tests/sampler/test_pints.py
@@ -6,7 +6,7 @@
 from .test_sampler_base import TestSamplerBase
 
 
-class TestMetropolis(TestSamplerBase):
+class TestPints(TestSamplerBase):
 
     def test_Haario(self):
         """Test Metropolis sampling."""

From 238c02e9b80baddcf29b2ea20f582f4c174be7c4 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Fri, 29 Oct 2021 14:57:58 +0200
Subject: [PATCH 086/286] clean up

---
 qmctorch/solver/solver_slater_jastrow.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/qmctorch/solver/solver_slater_jastrow.py b/qmctorch/solver/solver_slater_jastrow.py
index 3c51f5cb..61ee9017 100644
--- a/qmctorch/solver/solver_slater_jastrow.py
+++ b/qmctorch/solver/solver_slater_jastrow.py
@@ -385,7 +385,6 @@ def evaluate_grad_auto(self, lpos):
             loss += self.ortho_loss(self.wf.mo.weight)
 
         # compute local gradients
-        # self.opt.zero_grad() ???
         loss.backward()
 
         return loss, eloc
@@ -430,7 +429,6 @@ def evaluate_grad_manual(self, lpos):
             weight *= norm
 
             # compute the gradients
-            # self.opt.zero_grad()
             psi.backward(weight)
 
             return torch.mean(eloc), eloc

From 91958c13b426368b1139f8cc6c46b1a4875c09d1 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Mon, 14 Mar 2022 15:16:44 +0100
Subject: [PATCH 087/286] fix import issue

---
 example/single_point/h2.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/example/single_point/h2.py b/example/single_point/h2.py
index 881e84ae..004fdb22 100644
--- a/example/single_point/h2.py
+++ b/example/single_point/h2.py
@@ -3,7 +3,6 @@
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import SolverSlaterJastrow
-from qmctorch.utils import plot_walkers_traj
 from qmctorch.utils import set_torch_double_precision
 set_torch_double_precision()
 
@@ -26,19 +25,19 @@
                      logspace=False)
 
 
-pos = sampler(wf.pdf)
-e, s, err = wf._energy_variance_error(pos)
+# 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())
+# # print data
+# print('  Energy   : %f +/- %f' %
+#       (e.detach().item(), err.detach().item()))
+# print('  Variance : %f' % s.detach().item())
 
-# # solver
-# solver = SolverSlaterJastrow(wf=wf, sampler=sampler)
+# solver
+solver = SolverSlaterJastrow(wf=wf, sampler=sampler)
 
-# # single point
-# obs = solver.single_point(logspace=True)
+# single point
+obs = solver.single_point()
 
 # # reconfigure sampler
 # solver.sampler.ntherm = 0

From 39093c82ed33369b6ecb0dbbe60736c37e4fd984 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 24 Nov 2023 13:27:02 +0100
Subject: [PATCH 088/286] fix typos

---
 qmctorch/wavefunction/slater_jastrow.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 2953c3cd..358221f5 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -224,11 +224,7 @@ def forward(self, x, ao=None):
         """computes the value of the wave function for the sampling points
 
         .. math::
-<<<<<<< HEAD
-            J(R) \\Psi(R) =  J(R) \\sum_{n} c_n D^{u}_n(r^u) \\times D^{d}_n(r^d)
-=======
             \\Psi(R) =  J(R) \\sum_{n} c_n  D^{u}_n(r^u) \\times D^{d}_n(r^d)
->>>>>>> master
 
         Args:
             x (torch.tensor): sampling points (Nbatch, 3*Nelec)

From 64caa35ec16f543887df98b153c9686da4deb8cc Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 24 Nov 2023 16:36:47 +0100
Subject: [PATCH 089/286] fix path and module

---
 qmctorch/utils/plot_data.py               |  10 --
 tests/solver/test_h2.py                   | 178 ----------------------
 tests/solver/test_h2_adf.py               |   1 -
 tests/solver/test_h2_correlated.py        | 142 -----------------
 tests/solver/test_h2_pyscf_geo_opt.py     |   4 +-
 tests/solver/test_h2_pyscf_hamiltonian.py |   2 +-
 tests/solver/test_h2_pyscf_jacobi.py      |   2 +-
 tests/solver/test_h2_pyscf_metropolis.py  |   2 +-
 tests/solver/test_h2_pyscf_stats.py       |   8 +-
 9 files changed, 9 insertions(+), 340 deletions(-)
 delete mode 100644 tests/solver/test_h2.py
 delete mode 100644 tests/solver/test_h2_correlated.py

diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index da96c396..18d70ec8 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -86,15 +86,6 @@ def plot_walkers_traj(eloc, walkers='mean'):
                 plt.plot(celoc.T[:, i], color=cmap[i])
 
         elif walkers == 'mean':
-<<<<<<< HEAD
-            # plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
-            plt.plot(np.mean(celoc.T, axis=1), linewidth=5)
-
-        else:
-            plt.plot(eloc[walkers, :], 'o',
-                     alpha=max(1 / nwalkers, 1E-2), c='grey')
-            plt.plot(celoc.T[traj_index, :])
-=======
             plt.plot(eloc, 'o', alpha=1 / nwalkers, c='grey')
             emean = np.mean(celoc.T, axis=1)
             emin = emean.min()
@@ -105,7 +96,6 @@ def plot_walkers_traj(eloc, walkers='mean'):
         else:
             raise ValueError('walkers argument must be all or mean')
         
->>>>>>> master
         plt.grid()
         plt.xlabel('Monte Carlo Steps')
         plt.ylabel('Energy (Hartree)')
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 0bc38992..aabaf28e 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -2,7 +2,6 @@
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.scf import Molecule
-from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.sampler import Metropolis
 import unittest
 
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_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index efa3cfc1..ff62759e 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -6,7 +6,6 @@
 
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
 from qmctorch.utils.plot_data import (plot_block, plot_blocking_energy,
                                       plot_correlation_coefficient,
                                       plot_integrated_autocorrelation_time,
@@ -14,6 +13,7 @@
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from qmctorch.solver import Solver
 
 __PLOT__ = True
 
@@ -61,7 +61,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
     def test_geo_opt(self):
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index 05cc3337..f49e2aaf 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -7,7 +7,7 @@
 from .test_base_solver import BaseTestSolvers
 
 from qmctorch.sampler import Hamiltonian
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 4c1c05e1..6ccd99e3 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -7,7 +7,7 @@
 from .test_base_solver import BaseTestSolvers
 
 from qmctorch.sampler import Hamiltonian
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index ae1ad615..79f6ad39 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -8,7 +8,7 @@
 from .test_base_solver import BaseTestSolvers
 
 from qmctorch.sampler import Metropolis
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index 9d8a9bcf..76f77ddd 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,10 +6,10 @@
 
 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.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow

From 2fd615533de0d68e5647c8a0e3349633801d4450 Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Sat, 25 Nov 2023 11:50:56 +0100
Subject: [PATCH 090/286] Repalced SolverSalterJastrow by Solver

---
 docs/example/autocorrelation/h2.py        | 4 ++--
 notebooks/NeuralJastrow.ipynb             | 2 +-
 tests/solver/test_h2_pyscf_hamiltonian.py | 2 +-
 tests/solver/test_h2_pyscf_jacobi.py      | 2 +-
 tests/solver/test_h2_pyscf_metropolis.py  | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index 00cf3ccc..6c7ca9c9 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -3,7 +3,7 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.scf import Molecule
-from qmctorch.solver import SolverSlaterJastrow
+from qmctorch.solver import Solver
 from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
@@ -41,7 +41,7 @@
 
 opt = optim.Adam(wf.parameters(), lr=0.01)
 
-solver = SolverSlaterJastrow(wf=wf, sampler=sampler, optimizer=opt)
+solver = Solver(wf=wf, sampler=sampler, optimizer=opt)
 
 pos = solver.sampler(wf.pdf)
 obs = solver.sampling_traj(pos)
diff --git a/notebooks/NeuralJastrow.ipynb b/notebooks/NeuralJastrow.ipynb
index 548ce819..edb840e8 100644
--- a/notebooks/NeuralJastrow.ipynb
+++ b/notebooks/NeuralJastrow.ipynb
@@ -304,7 +304,7 @@
     "    scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)\n",
     "\n",
     "    # solver\n",
-    "    solver = SolverSlaterJastrow(wf=wf, sampler=sampler,\n",
+    "    solver = Solver(wf=wf, sampler=sampler,\n",
     "                                 optimizer=opt, scheduler=scheduler)\n",
     "\n",
     "    # optimize the wave function\n",
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index f49e2aaf..d02680d3 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -54,7 +54,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # values on different arch
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 6ccd99e3..6951f435 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -54,7 +54,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # values on different arch
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 79f6ad39..15bc1f28 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -60,7 +60,7 @@ def setUp(self):
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverSlaterJastrow(wf=self.wf, sampler=self.sampler,
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
                                           optimizer=self.opt)
 
         # values on different arch

From 8f41762aec5b33fe97ff251a86a3a5d8673df3a4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 27 Nov 2023 16:58:16 +0100
Subject: [PATCH 091/286] fix argument of SJ with orbital dependent Jastrow

---
 qmctorch/wavefunction/slater_orbital_dependent_jastrow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index d1756572..3b365569 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -51,7 +51,7 @@ def __init__(self, mol,
             raise ValueError(
                 '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(

From aa3b49527e710d46465d73f0e951dea446c77a8f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 27 Nov 2023 17:16:27 +0100
Subject: [PATCH 092/286] fix call to jastrow kernel

---
 qmctorch/wavefunction/slater_orbital_dependent_jastrow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 3b365569..52ddcc6d 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -55,7 +55,7 @@ def __init__(self, mol,
         self.use_jastrow = True
 
         self.jastrow = JastrowFactorElectronElectron(
-            self.mol.nup, self.mol.ndown, jastrow_kernel,
+            jastrow_kernel,
             kernel_kwargs=jastrow_kernel_kwargs,
             orbital_dependent_kernel=True,
             number_of_orbitals=self.nmo_opt,

From fd5703fb1904fa47ab8459433ef13a9ef5d461fa Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 10:30:05 +0100
Subject: [PATCH 093/286] fix arg

---
 qmctorch/wavefunction/slater_orbital_dependent_jastrow.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 52ddcc6d..15cec289 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -55,6 +55,7 @@ def __init__(self, mol,
         self.use_jastrow = True
 
         self.jastrow = JastrowFactorElectronElectron(
+            mol,
             jastrow_kernel,
             kernel_kwargs=jastrow_kernel_kwargs,
             orbital_dependent_kernel=True,

From fef65644d08f5e26fb6a165ab420abed185ccde0 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 10:48:46 +0100
Subject: [PATCH 094/286] reformat black

---
 docs/conf.py                                  | 146 ++++----
 docs/example/autocorrelation/h2.py            |  28 +-
 docs/example/backflow/backflow.py             |  27 +-
 docs/example/gpu/h2.py                        |  65 ++--
 docs/example/horovod/h2.py                    |  69 ++--
 docs/example/jast_graph.py                    |   6 +-
 docs/example/optimization/h2.py               |  58 ++--
 docs/example/scf/scf.py                       |  21 +-
 docs/example/single_point/h2.py               |  26 +-
 docs/example/single_point/h2o_sampling.py     |  29 +-
 h5x/baseimport.py                             |   6 +-
 qmctorch/__init__.py                          |   5 +-
 qmctorch/__version__.py                       |   2 +-
 qmctorch/sampler/__init__.py                  |  13 +-
 qmctorch/sampler/generalized_metropolis.py    |  77 +++--
 qmctorch/sampler/hamiltonian.py               |  57 ++--
 qmctorch/sampler/metropolis.py                | 147 ++++----
 qmctorch/sampler/metropolis_all_elec.py       | 102 +++---
 .../sampler/metropolis_hasting_all_elec.py    |  79 ++---
 qmctorch/sampler/pints_sampler.py             |  59 ++--
 qmctorch/sampler/proposal_kernels.py          |  15 +-
 qmctorch/sampler/sampler_base.py              |  40 +--
 .../state_dependent_normal_proposal.py        |  18 +-
 qmctorch/sampler/walkers.py                   |  70 ++--
 qmctorch/scf/__init__.py                      |   2 +-
 qmctorch/scf/calculator/__init__.py           |   2 +-
 qmctorch/scf/calculator/adf.py                | 168 ++++-----
 qmctorch/scf/calculator/calculator_base.py    |  21 +-
 qmctorch/scf/calculator/pyscf.py              |  83 +++--
 qmctorch/scf/molecule.py                      | 290 ++++++++--------
 qmctorch/solver/__init__.py                   |   3 +-
 qmctorch/solver/solver.py                     | 184 +++++-----
 qmctorch/solver/solver_base.py                | 316 ++++++++---------
 qmctorch/solver/solver_mpi.py                 | 140 ++++----
 qmctorch/utils/__init__.py                    |  65 ++--
 qmctorch/utils/algebra_utils.py               |  15 +-
 qmctorch/utils/hdf5_utils.py                  | 135 ++++----
 qmctorch/utils/interpolate.py                 | 169 +++++-----
 qmctorch/utils/plot_data.py                   | 108 +++---
 qmctorch/utils/stat_utils.py                  |   8 +-
 qmctorch/utils/torch_utils.py                 |  76 ++---
 qmctorch/wavefunction/__init__.py             |   6 +-
 .../wavefunction/jastrows/combine_jastrow.py  |  73 ++--
 .../distance/electron_electron_distance.py    |  51 ++-
 .../distance/electron_nuclei_distance.py      |  36 +-
 .../wavefunction/jastrows/distance/scaling.py |   4 +-
 .../jastrows/elec_elec/__init__.py            |   4 +-
 .../jastrow_factor_electron_electron.py       |  79 +++--
 .../kernels/fully_connected_jastrow_kernel.py |  53 ++-
 .../jastrow_kernel_electron_electron_base.py  |  15 +-
 .../elec_elec/kernels/pade_jastrow_kernel.py  |  43 ++-
 .../kernels/pade_jastrow_polynomial_kernel.py |  60 ++--
 .../orbital_dependent_jastrow_kernel.py       |  28 +-
 .../jastrows/elec_elec_nuclei/__init__.py     |   4 +-
 ...jastrow_factor_electron_electron_nuclei.py |  89 ++---
 .../elec_elec_nuclei/kernels/__init__.py      |   4 +-
 .../kernels/boys_handy_jastrow_kernel.py      |  15 +-
 .../kernels/fully_connected_jastrow_kernel.py |  11 +-
 ...ow_kernel_electron_electron_nuclei_base.py |  30 +-
 .../jastrow_factor_electron_nuclei.py         |  43 +--
 .../kernels/fully_connected_jastrow_kernel.py |   5 +-
 .../jastrow_kernel_electron_nuclei_base.py    |  15 +-
 .../kernels/pade_jastrow_kernel.py            |  26 +-
 .../jastrows/graph/elec_elec_graph.py         |  10 +-
 .../jastrows/graph/elec_nuc_graph.py          |  26 +-
 .../jastrows/graph/jastrow_graph.py           | 120 +++----
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  |  50 +--
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  45 ++-
 .../jastrows/jastrow_factor_combined_terms.py | 153 +++++----
 .../wavefunction/orbitals/atomic_orbitals.py  | 239 +++++++------
 .../orbitals/atomic_orbitals_backflow.py      |  77 +++--
 ...mic_orbitals_orbital_dependent_backflow.py |  80 +++--
 .../backflow/backflow_transformation.py       | 133 ++++----
 .../backflow_kernel_autodiff_inverse.py       |  10 +-
 .../backflow/kernels/backflow_kernel_base.py  |  17 +-
 .../backflow_kernel_fully_connected.py        |   3 +-
 .../kernels/backflow_kernel_inverse.py        |  12 +-
 .../kernels/backflow_kernel_power_sum.py      |   5 +-
 .../kernels/backflow_kernel_square.py         |   8 +-
 .../orbital_dependent_backflow_kernel.py      |  11 +-
 ...bital_dependent_backflow_transformation.py |  75 ++--
 .../wavefunction/orbitals/norm_orbital.py     |  88 ++---
 .../wavefunction/orbitals/radial_functions.py | 229 +++++++------
 .../orbitals/spherical_harmonics.py           | 319 +++++++++++-------
 .../pooling/orbital_configurations.py         | 132 ++++----
 .../wavefunction/pooling/orbital_projector.py |  89 +++--
 .../wavefunction/pooling/slater_pooling.py    | 283 +++++++++-------
 qmctorch/wavefunction/slater_jastrow.py       | 199 +++++------
 .../slater_orbital_dependent_jastrow.py       |  77 +++--
 .../trash/slater_combined_jastrow.py          |  58 ++--
 .../trash/slater_combined_jastrow_backflow.py | 108 +++---
 qmctorch/wavefunction/trash/slater_jastrow.py |  45 +--
 .../trash/slater_jastrow_backflow.py          |  89 ++---
 .../wavefunction/trash/slater_jastrow_base.py | 164 ++++-----
 .../trash/slater_jastrow_graph.py             |  57 ++--
 qmctorch/wavefunction/wf_base.py              | 113 +++----
 setup.py                                      |  72 ++--
 tests/path_utils.py                           |   2 +-
 tests/sampler/test_generalized_metropolis.py  |  11 +-
 tests/sampler/test_hamiltonian.py             |   4 +-
 tests/sampler/test_metropolis.py              |  23 +-
 tests/sampler/test_metropolis_hasting.py      |  16 +-
 tests/sampler/test_pints.py                   |  11 +-
 tests/sampler/test_sampler_base.py            |  18 +-
 tests/sampler/test_walker.py                  |  25 +-
 tests/scf/test_gto2sto_fit.py                 |  55 +--
 tests/scf/test_molecule.py                    |  55 ++-
 tests/solver/test_base_solver.py              |  15 +-
 tests/solver/test_h2_adf.py                   |  27 +-
 tests/solver/test_h2_adf_jacobi.py            |  26 +-
 tests/solver/test_h2_pyscf_geo_opt.py         |  55 ++-
 tests/solver/test_h2_pyscf_hamiltonian.py     |  29 +-
 tests/solver/test_h2_pyscf_jacobi.py          |  29 +-
 tests/solver/test_h2_pyscf_metropolis.py      |  50 ++-
 tests/solver/test_h2_pyscf_stats.py           |  39 ++-
 tests/solver/test_lih_adf_backflow.py         |  42 +--
 tests/solver/test_lih_correlated.py           |  34 +-
 tests/solver/test_lih_pyscf.py                |  31 +-
 tests/solver/test_lih_pyscf_backflow.py       |  48 +--
 .../solver/test_lih_pyscf_compare_backflow.py | 125 +++----
 .../solver/test_lih_pyscf_generic_backflow.py |  48 +--
 .../solver/test_lih_pyscf_generic_jastrow.py  |  40 +--
 ...st_lih_pyscf_orbital_dependent_backflow.py |  48 +--
 tests/utils/test_interpolate.py               |  36 +-
 tests/wavefunction/base_test_cases.py         | 110 +++---
 .../distance/test_elec_elec_distance.py       |  21 +-
 .../elec_elec/base_elec_elec_jastrow_test.py  |  62 ++--
 .../elec_elec/test_generic_jastrow.py         |  17 +-
 .../jastrows/elec_elec/test_pade_jastrow.py   |  15 +-
 .../elec_elec/test_pade_jastrow_polynom.py    |  23 +-
 .../elec_elec/test_scaled_pade_jastrow.py     |  16 +-
 .../test_scaled_pade_jastrow_polynom.py       |  25 +-
 .../jastrows/elec_elec_nuc/test_hess.py       |  16 +-
 .../test_three_body_jastrow_boys_handy.py     |  83 ++---
 ...test_three_body_jastrow_fully_connected.py |  77 ++---
 .../test_electron_nuclei_fully_connected.py   |  54 ++-
 .../test_electron_nuclei_pade_jastrow.py      |  54 ++-
 .../jastrows/graph/test_graph_jastrow.py      |  80 ++---
 .../jastrows/test_combined_terms.py           |  65 ++--
 .../test_backflow_kernel_generic_pyscf.py     | 104 +++---
 .../test_backflow_kernel_inverse_pyscf.py     |  96 +++---
 .../test_backflow_transformation_pyscf.py     |  55 ++-
 ...dependent_backflow_transformation_pyscf.py |  65 ++--
 tests/wavefunction/orbitals/base_test_ao.py   |  72 ++--
 .../orbitals/second_derivative.py             |   1 -
 .../orbitals/test_ao_derivatives_adf.py       |   5 +-
 .../orbitals/test_ao_derivatives_pyscf.py     |  12 +-
 .../orbitals/test_ao_values_adf.py            |  60 ++--
 .../orbitals/test_ao_values_pyscf.py          |  35 +-
 .../test_backflow_ao_derivatives_pyscf.py     |  77 ++---
 .../orbitals/test_cartesian_harmonics.py      |  73 ++--
 .../orbitals/test_cartesian_harmonics_adf.py  |  57 ++--
 .../orbitals/test_mo_values_adf.py            |  51 ++-
 tests/wavefunction/orbitals/test_norm.py      |  21 +-
 ...dependent_backflow_ao_derivatives_pyscf.py |  77 ++---
 .../orbitals/test_radial_functions.py         | 118 +++----
 .../wavefunction/orbitals/test_radial_gto.py  |  96 +++---
 .../wavefunction/orbitals/test_radial_sto.py  |  93 +++--
 .../orbitals/test_spherical_harmonics.py      |   3 +-
 tests/wavefunction/pooling/test_orbconf.py    |  20 +-
 tests/wavefunction/pooling/test_slater.py     |  57 ++--
 .../wavefunction/pooling/test_trace_trick.py  | 114 +++----
 .../test_compare_slaterjastrow_backflow.py    |  88 ++---
 ...laterjastrow_orbital_dependent_backflow.py |  81 ++---
 .../test_slater_mgcn_graph_jastrow.py         | 119 +++----
 .../test_slatercombinedjastrow.py             |  62 ++--
 .../test_slatercombinedjastrow_backflow.py    |  77 +++--
 .../test_slatercombinedjastrow_internal.py    |  38 ++-
 tests/wavefunction/test_slaterjastrow.py      |  38 +--
 .../test_slaterjastrow_backflow.py            |  41 +--
 tests/wavefunction/test_slaterjastrow_cas.py  |  35 +-
 .../test_slaterjastrow_ee_cusp.py             |  64 ++--
 .../test_slaterjastrow_generic.py             |  48 +--
 ...laterjastrow_orbital_dependent_backflow.py |  56 +--
 tests_hvd/test_h2_hvd.py                      |  55 +--
 175 files changed, 5264 insertions(+), 5400 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index f9cac9b1..58c16090 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -59,32 +59,33 @@
 
 
 autodoc_mock_imports = [
-    'numpy',
-    'scipy',
-    'h5py',
-    'twiggy',
-    'mpi4py',
-    'scipy.signal',
-    'torch',
-    'torch.utils',
-    'torch.utils.data',
-    'matplotlib',
-    'matplotlib.pyplot',
-    'torch.autograd',
-    'torch.nn',
-    'torch.optim',
-    'torch.cuda',
-    'torch.distributions',
-    'mendeleev',
-    'pandas',
-    'pyscf',
-    'adf',
-    'scm',
-    'tqdm',
-    'ase',
-    'horovod']
-
-sys.path.insert(0, os.path.abspath('../'))
+    "numpy",
+    "scipy",
+    "h5py",
+    "twiggy",
+    "mpi4py",
+    "scipy.signal",
+    "torch",
+    "torch.utils",
+    "torch.utils.data",
+    "matplotlib",
+    "matplotlib.pyplot",
+    "torch.autograd",
+    "torch.nn",
+    "torch.optim",
+    "torch.cuda",
+    "torch.distributions",
+    "mendeleev",
+    "pandas",
+    "pyscf",
+    "adf",
+    "scm",
+    "tqdm",
+    "ase",
+    "horovod",
+]
+
+sys.path.insert(0, os.path.abspath("../"))
 
 
 # -- General configuration ------------------------------------------------
@@ -97,58 +98,58 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'sphinx.ext.intersphinx',
-    'sphinx.ext.todo',
-    'sphinx.ext.coverage',
-    'sphinx.ext.mathjax',
-    'sphinx.ext.ifconfig',
-    'sphinx.ext.napoleon',
-    'sphinx.ext.viewcode',
-    'nbsphinx'
+    "sphinx.ext.autodoc",
+    "sphinx.ext.doctest",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.todo",
+    "sphinx.ext.coverage",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "nbsphinx",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = 'QMCTorch'
-copyright = '2020, Nicolas Renaud'
-author = 'Nicolas Renaud'
+project = "QMCTorch"
+copyright = "2020, Nicolas Renaud"
+author = "Nicolas Renaud"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '0.1'
+version = "0.1"
 # The full version, including alpha/beta/rc tags.
-release = '0.1.0'
+release = "0.1.0"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = 'en'
+language = "en"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -165,7 +166,7 @@
 # else:
 #     html_theme = 'classic'
 
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 html_logo = "./pics/qmctorch_white.png"
 
 # Theme options are theme-specific and customize the look and feel of a theme
@@ -180,7 +181,7 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -188,11 +189,11 @@
 # This is required for the alabaster theme
 # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
 html_sidebars = {
-    '**': [
-        'globaltoc.html',
-        'relations.html',  # needs 'show_related': True theme option to display
-        'sourcelink.html',
-        'searchbox.html',
+    "**": [
+        "globaltoc.html",
+        "relations.html",  # needs 'show_related': True theme option to display
+        "sourcelink.html",
+        "searchbox.html",
     ]
 }
 
@@ -200,7 +201,7 @@
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'QMCTorchdoc'
+htmlhelp_basename = "QMCTorchdoc"
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -209,15 +210,12 @@
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
-
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -227,8 +225,7 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'QMCTorch.tex', 'QMCTorch Documentation',
-     'Nicolas Renaud', 'manual'),
+    (master_doc, "QMCTorch.tex", "QMCTorch Documentation", "Nicolas Renaud", "manual"),
 ]
 
 
@@ -236,10 +233,7 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'qmctorch', 'QMCTorch Documentation',
-     [author], 1)
-]
+man_pages = [(master_doc, "qmctorch", "QMCTorch Documentation", [author], 1)]
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -248,18 +242,24 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'QMCTorch', 'QMCTorch Documentation',
-     author, 'QMCTorch', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "QMCTorch",
+        "QMCTorch Documentation",
+        author,
+        "QMCTorch",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
 
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {
-    'python': ('https://docs.python.org/', None),
-    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
-    'pytorch': ('http://pytorch.org/docs/1.4.0/', None),
+    "python": ("https://docs.python.org/", None),
+    "numpy": ("http://docs.scipy.org/doc/numpy/", None),
+    "pytorch": ("http://pytorch.org/docs/1.4.0/", None),
 }
 
-autoclass_content = 'init'
-autodoc_member_order = 'bysource'
-nbsphinx_allow_errors = True
\ No newline at end of file
+autoclass_content = "init"
+autodoc_member_order = "bysource"
+nbsphinx_allow_errors = True
diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index 6c7ca9c9..f27ffeaa 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -4,26 +4,26 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.scf import Molecule
 from qmctorch.solver import Solver
-from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
+from qmctorch.utils 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')
+    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)')
+wf = SlaterJastrow(mol, kinetic="auto", jastrow=jastrow, configs="single(2,2)")
 
 # sampler
 sampler = Metropolis(
@@ -34,10 +34,9 @@
     step_size=0.5,
     ndim=wf.ndim,
     nelec=wf.nelec,
-    init=mol.domain('normal'),
-    move={
-        'type': 'all-elec',
-        'proba': 'normal'})
+    init=mol.domain("normal"),
+    move={"type": "all-elec", "proba": "normal"},
+)
 
 opt = optim.Adam(wf.parameters(), lr=0.01)
 
@@ -47,7 +46,6 @@
 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"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 abc4de98..dd388495 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -13,7 +13,6 @@
 
 
 class MyBackflow(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, size=16):
         super().__init__(mol, cuda)
         self.fc1 = nn.Linear(1, size, bias=False)
@@ -27,20 +26,28 @@ def forward(self, x):
 
 
 # define the molecule
-mol = Molecule(atom='Li 0. 0. 0.; H 3.14 0. 0.', unit='angs',
-               calculator='pyscf', basis='sto-3g', name='LiH')
+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})
+backflow = BackFlowTransformation(mol, MyBackflow, {"size": 64})
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic='jacobi',
-                   jastrow=jastrow,
-                   backflow=backflow,
-                   configs='single_double(2,2)')
-
-pos = torch.rand(10, wf.nelec*3)
+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 755441ff..fcbaf1ef 100644
--- a/docs/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -6,7 +6,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
+from qmctorch.utils import plot_energy, plot_data
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -16,58 +16,65 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-               calculator='adf',
-               basis='dzp',
-               unit='bohr')
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator="adf", 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)
+wf = SlaterJastrow(
+    mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=True
+)
 
 # sampler
-sampler = Metropolis(nwalkers=2000,
-                     nstep=2000, step_size=0.2,
-                     ntherm=-1, ndecor=100,
-                     nelec=wf.nelec, init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'},
-                     cuda=True)
+sampler = Metropolis(
+    nwalkers=2000,
+    nstep=2000,
+    step_size=0.2,
+    ntherm=-1,
+    ndecor=100,
+    nelec=wf.nelec,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+    cuda=True,
+)
 
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
-           {'params': wf.ao.parameters(), 'lr': 1E-6},
-           {'params': wf.mo.parameters(), 'lr': 1E-3},
-           {'params': wf.fc.parameters(), 'lr': 2E-3}]
-opt = optim.Adam(lr_dict, lr=1E-3)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 3e-3},
+    {"params": wf.ao.parameters(), "lr": 1e-6},
+    {"params": wf.mo.parameters(), "lr": 1e-3},
+    {"params": wf.fc.parameters(), "lr": 2e-3},
+]
+opt = optim.Adam(lr_dict, lr=1e-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # 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()
 
 # optimize the wave function
 # configure the solver
-solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                 loss='energy', grad='auto',
-                 ortho_mo=False, clip_loss=False,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 50})
+solver.configure(
+    track=["local_energy"],
+    freeze=["ao", "mo"],
+    loss="energy",
+    grad="auto",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+)
 
 # optimize the wave function
 obs = solver.run(250)
 
 plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname='jastrow.weight')
+plot_data(solver.observable, obsname="jastrow.weight")
diff --git a/docs/example/horovod/h2.py b/docs/example/horovod/h2.py
index 4e4b76f3..7ce8207b 100644
--- a/docs/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import SolverMPI
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
+from qmctorch.utils import plot_energy, plot_data
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -22,51 +22,64 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', unit='bohr',
-               calculator='pyscf', basis='sto-3g',
-               rank=hvd.local_rank(), mpi_size=hvd.local_size())
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69",
+    unit="bohr",
+    calculator="pyscf",
+    basis="sto-3g",
+    rank=hvd.local_rank(),
+    mpi_size=hvd.local_size(),
+)
 
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic='jacobi',
-                   configs='cas(2,2)',
-                   cuda=use_cuda)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="cas(2,2)", cuda=use_cuda)
 
 # sampler
-sampler = Metropolis(nwalkers=200,
-                     nstep=200, step_size=0.2,
-                     ntherm=-1, ndecor=100,
-                     nelec=wf.nelec, init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'},
-                     cuda=use_cuda)
+sampler = Metropolis(
+    nwalkers=200,
+    nstep=200,
+    step_size=0.2,
+    ntherm=-1,
+    ndecor=100,
+    nelec=wf.nelec,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+    cuda=use_cuda,
+)
 
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
-           {'params': wf.ao.parameters(), 'lr': 1E-6},
-           {'params': wf.mo.parameters(), 'lr': 1E-3},
-           {'params': wf.fc.parameters(), 'lr': 2E-3}]
-opt = optim.Adam(lr_dict, lr=1E-3)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 3e-3},
+    {"params": wf.ao.parameters(), "lr": 1e-6},
+    {"params": wf.mo.parameters(), "lr": 1e-3},
+    {"params": wf.fc.parameters(), "lr": 2e-3},
+]
+opt = optim.Adam(lr_dict, lr=1e-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverMPI(wf=wf, sampler=sampler,
-                                    optimizer=opt, scheduler=scheduler,
-                                    rank=hvd.rank())
+solver = SolverMPI(
+    wf=wf, sampler=sampler, optimizer=opt, scheduler=scheduler, rank=hvd.rank()
+)
 
 # configure the solver
-solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                 loss='energy', grad='auto',
-                 ortho_mo=False, clip_loss=False,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 50})
+solver.configure(
+    track=["local_energy"],
+    freeze=["ao", "mo"],
+    loss="energy",
+    grad="auto",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+)
 
 # optimize the wave function
 obs = solver.run(250)
 
 if hvd.rank() == 0:
     plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-    plot_data(solver.observable, obsname='jastrow.weight')
+    plot_data(solver.observable, obsname="jastrow.weight")
diff --git a/docs/example/jast_graph.py b/docs/example/jast_graph.py
index 4df30937..1dfb4c9b 100644
--- a/docs/example/jast_graph.py
+++ b/docs/example/jast_graph.py
@@ -1,14 +1,12 @@
-
 from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
 import torch
 from torch.autograd import grad
+
 nup = 2
 ndown = 2
 atomic_pos = torch.rand(2, 3)
 atom_types = ["Li", "H"]
-jast = JastrowFactorGraph(nup, ndown,
-                          atomic_pos,
-                          atom_types)
+jast = JastrowFactorGraph(nup, ndown, atomic_pos, atom_types)
 
 
 pos = torch.rand(10, 12)
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index ca6aedac..41354569 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils.plot_data import (plot_energy, plot_data)
+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
 
@@ -21,18 +21,15 @@
 np.random.seed(0)
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-               calculator='pyscf',
-               basis='sto-3g',
-               unit='bohr')
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator="pyscf", 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=jastrow)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="single_double(2,2)", jastrow=jastrow)
 
 # sampler
 # sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
@@ -40,15 +37,24 @@
 #                       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'))
+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},
-           {'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)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 1e-2},
+    {"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)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
@@ -60,14 +66,20 @@
 # 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,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 150,
-                             'ntherm_update': 50}
-                 )
+solver.configure(
+    track=["local_energy", "parameters"],
+    freeze=["ao"],
+    loss="energy",
+    grad="manual",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={
+        "mode": "update",
+        "resample_every": 1,
+        "nstep_update": 150,
+        "ntherm_update": 50,
+    },
+)
 
 # optimize the wave function
 obs = solver.run(5)  # , batchsize=10)
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index a609f866..48d7656e 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -1,23 +1,12 @@
 from qmctorch.scf import Molecule
 
 # Select the SCF calculator
-calc = ['pyscf',            # pyscf  
-        'adf',          # adf 2019 
-        'adf2019'               # adf 2020+
-    ][1]
+calc = ["pyscf", "adf", "adf2019"][1]  # pyscf  # adf 2019  # adf 2020+
 
 # select an appropriate basis
-basis = {
-    'pyscf'  : 'sto-6g',
-    'adf'    : 'VB1',
-    'adf2019': 'dz'
-}[calc]
+basis = {"pyscf": "sto-6g", "adf": "VB1", "adf2019": "dz"}[calc]
 
 # do the scf calculation
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-            calculator=calc,
-            basis=basis,
-            unit='bohr')
-
-
-
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator=calc, basis=basis, unit="bohr"
+)
diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
index 27017364..5f8126f1 100644
--- a/docs/example/single_point/h2.py
+++ b/docs/example/single_point/h2.py
@@ -4,25 +4,33 @@
 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')
+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()
+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)
+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)
diff --git a/docs/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
index 507a78cb..d07b3086 100644
--- a/docs/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -7,22 +7,31 @@
 
 
 # define the molecule
-mol = Molecule(atom='water.xyz', unit='angs',
-               calculator='pyscf', basis='sto-3g' , 
-               name='water', redo_scf=True)
+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', jastrow=jastrow)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="ground_state", jastrow=jastrow)
 
 # sampler
-sampler = Metropolis(nwalkers=1000, nstep=500, step_size=0.25,
-                     nelec=wf.nelec, ndim=wf.ndim,
-                     init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'})
+sampler = Metropolis(
+    nwalkers=1000,
+    nstep=500,
+    step_size=0.25,
+    nelec=wf.nelec,
+    ndim=wf.ndim,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+)
 
 # solver
 solver = Solver(wf=wf, sampler=sampler)
@@ -37,4 +46,4 @@
 # compute the sampling traj
 pos = solver.sampler(solver.wf.pdf)
 obs = solver.sampling_traj(pos)
-plot_walkers_traj(obs.local_energy, walkers='mean')
+plot_walkers_traj(obs.local_energy, walkers="mean")
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 44339111..a40f53e8 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,5 +1,9 @@
 from qmctorch.utils.plot_data import (
-    plot_energy, plot_data, plot_block, plot_walkers_traj)
+    plot_energy,
+    plot_data,
+    plot_block,
+    plot_walkers_traj,
+)
 import matplotlib.pyplot as plt
 import numpy as np
 
diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 1c88fa72..9589dc8c 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -4,12 +4,13 @@
 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"  ____    __  ______________             _")
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 73e3bb4f..f9aa3e11 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = "0.3.2"
diff --git a/qmctorch/sampler/__init__.py b/qmctorch/sampler/__init__.py
index 8b135be4..6a58bffc 100644
--- a/qmctorch/sampler/__init__.py
+++ b/qmctorch/sampler/__init__.py
@@ -1,10 +1,11 @@
 __all__ = [
-    'SamplerBase',
-    'Metropolis',
-    'Hamiltonian',
-    'PintsSampler',
-    'MetropolisHasting',
-    'GeneralizedMetropolis']
+    "SamplerBase",
+    "Metropolis",
+    "Hamiltonian",
+    "PintsSampler",
+    "MetropolisHasting",
+    "GeneralizedMetropolis",
+]
 
 from .sampler_base import SamplerBase
 from .metropolis import Metropolis
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 3a2b53e7..dbf9deef 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -9,12 +9,18 @@
 
 
 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__(
+        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,
+    ):
         """Generalized Metropolis Hasting sampler
 
         Args:
@@ -29,9 +35,9 @@ def __init__(self, nwalkers=100, nstep=1000, step_size=3,
             cuda (bool, optional): use cuda. 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
+        )
 
     def __call__(self, pdf, pos=None, with_tqdm=True):
         """Generate a series of point using MC sampling
@@ -46,7 +52,6 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
             torch.tensor: positions of the walkers
         """
         with torch.no_grad():
-
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
@@ -58,22 +63,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)
@@ -89,17 +95,18 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
                 # 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
 
@@ -117,15 +124,12 @@ def move(self, drift):
 
         # clone and reshape data : Nwlaker, Nelec, Ndim
         new_pos = self.walkers.pos.clone()
-        new_pos = new_pos.view(self.walkers.nwalkers,
-                               self.nelec, self.ndim)
+        new_pos = new_pos.view(self.walkers.nwalkers, self.nelec, self.ndim)
 
         # get indexes
-        index = torch.LongTensor(self.walkers.nwalkers).random_(
-            0, self.nelec)
+        index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
 
-        new_pos[range(self.walkers.nwalkers), index,
-                :] += self._move(drift, index)
+        new_pos[range(self.walkers.nwalkers), index, :] += self._move(drift, index)
 
         return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -140,14 +144,16 @@ def _move(self, drift, index):
             torch.tensor: position of the walkers
         """
 
-        d = drift.view(self.walkers.nwalkers,
-                       self.nelec, self.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))
+        mv = MultivariateNormal(
+            torch.zeros(self.ndim), np.sqrt(self.step_size) * torch.eye(self.ndim)
+        )
 
-        return self.step_size * d[range(self.walkers.nwalkers), index, :] \
+        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
@@ -161,7 +167,7 @@ def trans(self, xf, xi, drifti):
             [type]: [description]
         """
         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):
         """Compute the drift velocity
@@ -174,13 +180,10 @@ 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):
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 22496181..ce592117 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -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,9 +36,9 @@ 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
@@ -99,16 +100,19 @@ 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,8 +122,9 @@ 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
@@ -143,7 +148,7 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = torch.randn(q.shape)
 
         # initial energy terms
-        E_init = U(q) + 0.5 * (p*p).sum(1)
+        E_init = U(q) + 0.5 * (p * p).sum(1)
 
         # half step in momentum space
         p -= 0.5 * epsilon * get_grad(U, q)
@@ -163,11 +168,11 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = -p
 
         # current energy term
-        E_new = U(q) + 0.5 * (p*p).sum(1)
+        E_new = U(q) + 0.5 * (p * p).sum(1)
 
         # 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
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 115b835d..2fda5633 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,19 +8,20 @@
 
 
 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'},
-                 logspace: bool = False,
-                 cuda: bool = False):
+    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"},
+        logspace: bool = False,
+        cuda: bool = False,
+    ):
         """Metropolis Hasting generator
 
         Args:
@@ -51,9 +52,9 @@ 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)
@@ -61,9 +62,8 @@ def __init__(self,
 
     def log_data(self):
         """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):
@@ -77,8 +77,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -93,15 +97,14 @@ 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
 
@@ -114,15 +117,15 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             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)
 
@@ -133,33 +136,36 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                     else:
                         # new function
                         fxn = pdf(Xn)
-                        fxn[fxn == 0.] = eps
+                        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.walkers.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_()
 
@@ -182,28 +188,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:
@@ -219,27 +227,22 @@ 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.walkers.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.walkers.nwalkers).random_(
-                    0, self.nelec)
+                index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
             else:
-                index = torch.LongTensor(
-                    self.walkers.nwalkers).fill_(id_elec)
+                index = torch.LongTensor(self.walkers.nwalkers).fill_(id_elec)
 
             # change selected data
-            new_pos[range(self.walkers.nwalkers), index,
-                    :] += self._move(1)
+            new_pos[range(self.walkers.nwalkers), index, :] += self._move(1)
 
             return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -252,17 +255,17 @@ 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.walkers.nwalkers, num_elec, self.ndim), device=self.device).view(
-                self.walkers.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)
+            return self.step_size * (2.0 * d - 1.0)
 
-        elif self.movedict['proba'] == 'normal':
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 1a81e923..9184ad7f 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -8,19 +8,20 @@
 
 
 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):
+    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:
@@ -51,26 +52,27 @@ 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.movedict = move
 
-        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.log_data()
 
     def log_data(self):
         """log data about the sampler."""
-        log.info('  Move type           : {0}', 'all-elec')
-        log.info(
-            '  Move proba          : {0}', self.movedict['proba'])
+        log.info("  Move type           : {0}", "all-elec")
+        log.info("  Move proba          : {0}", self.movedict["proba"])
 
     @staticmethod
     def log_func(func):
@@ -84,8 +86,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -105,10 +111,9 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         #     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
 
@@ -121,13 +126,14 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             # 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:
-
                 # new positions
                 Xn = self.move(pdf)
 
@@ -145,26 +151,27 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 index = self._accept(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to('cpu') / \
-                    (self.walkers.nwalkers)
+                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())
+                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_()
 
@@ -189,16 +196,17 @@ 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.walkers.nwalkers, num_elec*self.ndim), device=self.device)
-            return self.step_size * (2. * d - 1.)
+                (self.walkers.nwalkers, num_elec * self.ndim), device=self.device
+            )
+            return self.step_size * (2.0 * d - 1.0)
 
-        elif self.movedict['proba'] == 'normal':
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index 1934e877..b1473878 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -10,18 +10,19 @@
 
 
 class MetropolisHasting(SamplerBase):
-
-    def __init__(self,
-                 kernel=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):
+    def __init__(
+        self,
+        kernel=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,
+    ):
         """Metropolis Hasting generator
 
         Args:
@@ -52,12 +53,11 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             0.0, ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, 0.0, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
-        self.proposal = StateDependentNormalProposal(
-            kernel, nelec, ndim, self.device)
+        self.proposal = StateDependentNormalProposal(kernel, nelec, ndim, self.device)
 
         self.proposal.kernel.nelec = nelec
         self.proposal.kernel.ndim = ndim
@@ -82,8 +82,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -97,10 +101,9 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         """
 
         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
 
@@ -109,16 +112,16 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
 
             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:
-
                 # new positions
-                Xn = self.walkers.pos + \
-                    self.proposal(self.walkers.pos)
+                Xn = self.walkers.pos + self.proposal(self.walkers.pos)
 
                 # new function
                 fxn = pdf(Xn)
@@ -127,8 +130,7 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 prob_ratio = fxn / fx
 
                 # get transition ratio
-                trans_ratio = self.proposal.get_transition_ratio(
-                    self.walkers.pos, Xn)
+                trans_ratio = self.proposal.get_transition_ratio(self.walkers.pos, Xn)
 
                 # get the proba
                 df = prob_ratio * trans_ratio
@@ -137,25 +139,26 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 index = self.accept_reject(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to('cpu') / \
-                    (self.walkers.nwalkers)
+                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())
+                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_()
 
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index fc923f8f..a81c03be 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -7,7 +7,6 @@
 
 
 class torch_model(pints.LogPDF):
-
     def __init__(self, pdf, ndim):
         """Ancillary class tha wrap the wave function in a PINTS class
 
@@ -44,7 +43,7 @@ def evaluateS1(self, x):
         pdf = self.pdf(x)
         log_pdf = torch.log(pdf)
         x.requires_grad = True
-        grad_log_pdf = 1./pdf * self.pdf(x, return_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):
@@ -53,20 +52,21 @@ def n_parameters(self):
 
 
 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):
+    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:
@@ -97,9 +97,9 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep, None,
-                             ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, None, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
         self.method = method
         self.method_requires_grad = method_requires_grad
@@ -125,8 +125,12 @@ def log_func(func):
 
         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:
+    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:
@@ -140,14 +144,13 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         """
 
         if self.ntherm >= self.nstep:
-            raise ValueError('Thermalisation longer than trajectory')
+            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
 
@@ -155,12 +158,16 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             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)
+                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)
+        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
index fd96a120..eaa30c2e 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -8,8 +8,7 @@
 
 
 class DensityVarianceKernel(object):
-
-    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
+    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
@@ -18,7 +17,7 @@ def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1. - d).sum(-1)
+        out = self.sigma * (1.0 - d).sum(-1)
         return out.unsqueeze(-1)
 
     def get_atomic_distance(self, pos):
@@ -29,14 +28,12 @@ def get_atomic_distance(self, pos):
 
     def get_estimate_density(self, pos):
         d = self.get_atomic_distance(pos)
-        d = torch.exp(-self.scale_factor*d**2)
+        d = torch.exp(-self.scale_factor * d**2)
         return d
 
 
 class CenterVarianceKernel(object):
-
-    def __init__(self, sigma=1., scale_factor=1.):
-
+    def __init__(self, sigma=1.0, scale_factor=1.0):
         self.sigma = sigma
         self.scale_factor = scale_factor
         self.nelec = None
@@ -44,14 +41,14 @@ def __init__(self, sigma=1., scale_factor=1.):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1. - d)
+        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)
+        d = torch.exp(-self.scale_factor * d**2)
         return d
 
 
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index b3be0870..f9dd33f6 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -5,10 +5,9 @@
 
 
 class SamplerBase:
-
-    def __init__(self, nwalkers, nstep, step_size,
-                 ntherm, ndecor, nelec, ndim, init,
-                 cuda):
+    def __init__(
+        self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+    ):
         """Base class for the sampler
 
         Args:
@@ -32,32 +31,35 @@ 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.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'])
+        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, *args, **kwargs):
-        raise NotImplementedError(
-            "Sampler must have a __call__ method")
+        raise NotImplementedError("Sampler must have a __call__ method")
 
     def __repr__(self):
-        return self.__class__.__name__ + ' sampler with  %d walkers' % self.walkers.nwalkers
+        return (
+            self.__class__.__name__
+            + " sampler with  %d walkers" % self.walkers.nwalkers
+        )
 
     def get_sampling_size(self):
         """evaluate the number of sampling point we'll have."""
         if self.ntherm == -1:
             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
index 941a9640..b70a6a2b 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -8,34 +8,30 @@
 
 
 class StateDependentNormalProposal(object):
-
     def __init__(self, kernel, nelec, ndim, device):
-
         self.ndim = ndim
         self.nelec = nelec
         self.kernel = kernel
         self.device = device
         self.multiVariate = MultivariateNormal(
-            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
+            torch.zeros(self.ndim), 1.0 * torch.eye(self.ndim)
+        )
 
     def __call__(self, x):
         nwalkers = x.shape[0]
         scale = self.kernel(x)
-        displacement = self.multiVariate.sample(
-            (nwalkers, self.nelec)).to(self.device)
+        displacement = self.multiVariate.sample((nwalkers, self.nelec)).to(self.device)
         displacement *= scale
-        return displacement.view(nwalkers, self.nelec*self.ndim)
+        return displacement.view(nwalkers, self.nelec * self.ndim)
 
     def get_transition_ratio(self, x, y):
         sigmax = self.kernel(x)
         sigmay = self.kernel(y)
 
-        rdist = (x-y).view(-1, self.nelec,
-                           self.ndim).norm(dim=-1).unsqueeze(-1)
+        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./sigmay-1./sigmax))
+        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/walkers.py b/qmctorch/sampler/walkers.py
index 4b88fd12..c18411c2 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -6,9 +6,14 @@
 
 
 class Walkers(object):
-
-    def __init__(self, nwalkers: int = 100, nelec: int = 1, ndim: int = 3,
-                 init: Union[Dict, None] = None, cuda: bool = False):
+    def __init__(
+        self,
+        nwalkers: int = 100,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Union[Dict, None] = None,
+        cuda: bool = False,
+    ):
         """Creates Walkers for the sampler.
 
         Args:
@@ -29,9 +34,9 @@ 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):
         """Initalize the position of the walkers
@@ -44,29 +49,29 @@ 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):
         """Initialize the walkers at the center of the molecule
@@ -74,12 +79,9 @@ def _init_center(self):
         Returns:
             torch.tensor: positions of the walkers
         """
-        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)
+        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):
         """Initialize the walkers in a box covering the molecule
@@ -88,11 +90,9 @@ def _init_uniform(self):
             torch.tensor: positions of the walkers
         """
         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
@@ -101,10 +101,10 @@ def _init_multivar(self):
             torch.tensor -- positions of the walkers
         """
         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"]),
+        )
+        pos = multi.sample((self.nwalkers, self.nelec)).type(torch.get_default_dtype())
         pos = pos.view(self.nwalkers, self.nelec * self.ndim)
         return pos.to(device=self.device)
 
@@ -118,30 +118,26 @@ def _init_atomic(self):
         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 fbd91714..a63d7f72 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -11,40 +11,51 @@
 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__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
-
+    def __init__(
+        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+    ):
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'adf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "adf",
+            savefile,
+        )
 
         # 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):
         """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()
@@ -74,8 +85,8 @@ def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
         bohr2angs = 0.529177
-        scale = 1.
-        if self.units == 'bohr':
+        scale = 1.0
+        if self.units == "bohr":
             scale = bohr2angs
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(scale * np.array(xyz))
@@ -86,30 +97,32 @@ def get_plams_settings(self):
         """Returns 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
@@ -128,46 +141,46 @@ def get_basis_data(self, kffile):
 
         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 = [], [], []
@@ -175,7 +188,6 @@ def get_basis_data(self, kffile):
         basis_bas_exp, basis_bas_norm = [], []
 
         for iat, at in enumerate(atom_type):
-
             number_copy = nqptr[iat + 1] - nqptr[iat]
             idx_bos = list(range(nbptr[iat] - 1, nbptr[iat + 1] - 1))
 
@@ -186,8 +198,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
@@ -203,11 +214,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
@@ -215,12 +225,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
@@ -243,17 +253,17 @@ def read_array(kf, section, name):
         if data.shape == ():
             data = np.array([data])
         return data
-        
-class CalculatorADF2019(CalculatorADF):
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
 
+class CalculatorADF2019(CalculatorADF):
+    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, savefile)
+            self, atoms, atom_coords, basis, scf, units, molname, savefile
+        )
 
-        self.adf_version = 'adf2019'
-        self.job_name = ''.join(self.atoms) + '_' + self.basis_name
-        self.output_file = self.job_name + '.t21'
+        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."""
@@ -269,20 +279,20 @@ def get_plams_settings(self):
         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
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index 6ae267ae..007a69a0 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -2,8 +2,19 @@
 
 
 class CalculatorBase:
-    def __init__(self, atoms, atom_coords, basis, charge, spin, 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
@@ -16,12 +27,10 @@ def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname,
         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 1e7904fa..06d75fe9 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -8,11 +8,22 @@
 
 
 class CalculatorPySCF(CalculatorBase):
-
-    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
-
+    def __init__(
+        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+    ):
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'pyscf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "pyscf",
+            savefile,
+        )
 
     def run(self):
         """Run the scf calculation using PySCF."""
@@ -26,20 +37,21 @@ def run(self):
             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
 
@@ -55,7 +67,7 @@ def get_basis_data(self, mol, rhf):
         """
 
         # 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]}
@@ -64,9 +76,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
@@ -88,7 +99,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)
 
@@ -104,17 +114,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
@@ -160,15 +169,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)
@@ -196,23 +206,21 @@ def get_basis_data(self, mol, rhf):
         return basis
 
     def get_atoms_str(self):
-        """Refresh the atom string (use after atom move). """
-        atoms_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"]
 
-        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:
@@ -221,10 +229,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 8160b6cf..ba9a07d2 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -13,22 +13,32 @@
 try:
     from mpi4py import MPI
 except ModuleNotFoundError:
-    log.info('  MPI not found.')
+    log.info("  MPI not found.")
 
 
 class Molecule:
-
-    def __init__(self, atom=None, calculator='adf',
-                 scf='hf', basis='dzp', unit='bohr',
-                 charge=0, spin=0,
-                 name=None, load=None, save_scf_file=False,
-                 redo_scf=False, rank=0, mpi_size=0):
+    def __init__(
+        self,
+        atom=None,
+        calculator="adf",
+        scf="hf",
+        basis="dzp",
+        unit="bohr",
+        charge=0,
+        spin=0,
+        name=None,
+        load=None,
+        save_scf_file=False,
+        redo_scf=False,
+        rank=0,
+        mpi_size=0,
+    ):
         """Create a molecule in QMCTorch
 
         Args:
             atom (str or None, optional): defines the atoms and their positions. Defaults to None.
                 - At1 x y z; At2 x y z ... : Provide the atomic coordinate directly
-                - <file>.xyz : provide the path to an .xyz file containing the atomic coordinates 
+                - <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
@@ -75,91 +85,88 @@ def __init__(self, atom=None, calculator='adf',
         self.scf_level = 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.charge,
-                                           self.spin,
-                                           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()
 
             if mpi_size != 0:
-
                 MPI.COMM_WORLD.barrier()
 
                 if rank != 0:
-                    log.info(
-                        '  Loading data from {file}', file=self.hdf5file)
+                    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)
-        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("  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 Energy          : {:.3f} Hartree'.format(self.get_total_energy()))
+            "  SCF Energy          : {:.3f} Hartree".format(self.get_total_energy())
+        )
 
     def domain(self, method):
         """Returns information to initialize the walkers
@@ -178,42 +185,39 @@ 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):
         """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)
 
@@ -228,17 +232,14 @@ 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':
+            if self.unit == "angs":
                 conv2bohr = 1.8897259886
-            self.atom_coords.append(
-                [x * conv2bohr, y * conv2bohr, z * conv2bohr])
+            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
 
@@ -247,11 +248,12 @@ def _get_atomic_properties(self, atoms):
 
         # size of the system
         self.natom = len(self.atoms)
-        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)
+        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:
@@ -264,20 +266,20 @@ def _read_xyz_file(self):
         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 = ''
+        mol_name = ""
         unique_atoms = list(set(atoms))
         for ua in unique_atoms:
             mol_name += ua
@@ -289,48 +291,46 @@ def _get_mol_name(atoms):
     def _load_basis(self):
         """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
@@ -343,31 +343,39 @@ 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):
         """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):
         """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):
         """Load a molecule from hdf5
@@ -377,26 +385,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/solver.py b/qmctorch/solver/solver.py
index 94363fbb..11818411 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -2,18 +2,16 @@
 from time import time
 
 import torch
-from qmctorch.utils import (Loss,
-                            OrthoReg, add_group_attr,
-                            dump_to_hdf5, DataLoader)
+from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 
 from .. import log
 from .solver_base import SolverBase
 
 
 class Solver(SolverBase):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Basic QMC solver
 
         Args:
@@ -24,22 +22,30 @@ 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=None,
+        freeze=None,
+        loss=None,
+        grad=None,
+        ortho_mo=None,
+        clip_loss=False,
+        resampling=None,
+    ):
         """Configure the solver
 
         Args:
@@ -69,8 +75,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,8 +86,7 @@ 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.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
         if ortho_mo is not None:
@@ -99,7 +105,7 @@ 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'):
+        if hasattr(self.wf, "jastrow"):
             for param in self.wf.jastrow.parameters():
                 param.requires_grad = wf_params
 
@@ -117,33 +123,32 @@ 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
 
                 else:
-                    opt_freeze = ['ci', 'mo', 'ao', 'jastrow']
-                    raise ValueError(
-                        'Valid arguments for freeze are :', opt_freeze)
+                    opt_freeze = ["ci", "mo", "ao", "jastrow"]
+                    raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
     def save_sampling_parameters(self, pos):
-        """ save the sampling params."""
+        """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
 
-        if self.resampling_options.mode == 'update':
+        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]
@@ -154,9 +159,17 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.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):
+    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:
@@ -183,31 +196,27 @@ def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
 
         # log data
         self.prepare_optimization(batchsize, None, tqdm)
-        self.log_data_opt(nepoch, 'geometry optimization')
+        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.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.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.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
@@ -228,8 +237,9 @@ def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
 
         return self.observable
 
-    def run(self, nepoch, batchsize=None,
-            hdf5_group='wf_opt', chkpt_every=None, tqdm=False):
+    def run(
+        self, nepoch, batchsize=None, hdf5_group="wf_opt", chkpt_every=None, tqdm=False
+    ):
         """Run a wave function optimization
 
         Args:
@@ -245,7 +255,7 @@ def run(self, nepoch, batchsize=None,
 
         # 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)
@@ -277,8 +287,7 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         self.save_sampling_parameters(pos)
 
         # create the data loader
-        self.dataloader = DataLoader(
-            pos, batch_size=batchsize, pin_memory=self.cuda)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -294,10 +303,9 @@ 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):
         """Run a certain number of epochs
@@ -311,11 +319,11 @@ def run_epochs(self, nepoch):
 
         # loop over the epoch
         for n in range(nepoch):
-
             tstart = time()
-            log.info('')
-            log.info('  epoch %d | %d sampling points' %
-                     (n, len(self.dataloader.dataset)))
+            log.info("")
+            log.info(
+                "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
+            )
 
             cumulative_loss = 0
 
@@ -323,7 +331,6 @@ def run_epochs(self, nepoch):
 
             # loop over the batches
             for ibatch, data in enumerate(self.dataloader):
-
                 # port data to device
                 lpos = data.to(self.device)
 
@@ -333,12 +340,11 @@ 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
 
                 # 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)
@@ -346,8 +352,7 @@ def run_epochs(self, nepoch):
             # 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:
@@ -357,14 +362,13 @@ def run_epochs(self, nepoch):
             self.print_observable(cumulative_loss, verbose=False)
 
             # resample the data
-            self.dataloader.dataset = self.resample(
-                n, self.dataloader.dataset)
+            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))
+            log.info("  epoch done in %1.2f sec." % (time() - tstart))
 
         return cumulative_loss
 
@@ -405,28 +409,26 @@ 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 and wf values
             _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
             psi = self.wf(lpos)
-            norm = 1. / len(psi)
+            norm = 1.0 / len(psi)
 
             # evaluate the prefactor of the grads
             weight = eloc.clone()
             weight -= torch.mean(eloc)
             weight /= psi
-            weight *= 2.
+            weight *= 2.0
             weight *= norm
 
             # compute the gradients
@@ -435,30 +437,22 @@ def evaluate_grad_manual(self, lpos):
             return torch.mean(eloc), eloc
 
         else:
-            raise ValueError(
-                'Manual gradient only for energy minimization')
+            raise ValueError("Manual gradient only for energy minimization")
 
     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 497050c1..ce5c1f41 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -11,10 +11,9 @@
 
 
 class SolverBase:
-
-    def __init__(self, wf=None, sampler=None,
-                 optimizer=None, scheduler=None,
-                 output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Base Class for QMC solver
 
         Args:
@@ -31,7 +30,7 @@ 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("cpu")
 
         # member defined in the child and or method
         self.dataloader = None
@@ -39,33 +38,38 @@ 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 = "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
         if output is None:
-            basename = os.path.basename(
-                self.wf.mol.hdf5file).split('.')[0]
-            self.hdf5file = basename + '_QMCTorch.hdf5'
+            basename = os.path.basename(self.wf.mol.hdf5file).split(".")[0]
+            self.hdf5file = basename + "_QMCTorch.hdf5"
 
         if rank == 0:
             dump_to_hdf5(self, self.hdf5file)
 
         self.log_data()
 
-    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25, ntherm_update=-1,
-                             increment={'every': None, 'factor': None}):
+    def configure_resampling(
+        self,
+        mode="update",
+        resample_every=1,
+        nstep_update=25,
+        ntherm_update=-1,
+        increment={"every": None, "factor": None},
+    ):
         """Configure the resampling
 
         Args:
@@ -84,10 +88,9 @@ def configure_resampling(self, mode='update', resample_every=1, nstep_update=25,
         """
 
         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
@@ -108,47 +111,47 @@ 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()
 
         # 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()):
                     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()):
                     if p.requires_grad:
-                        self.observable.__setattr__(key+'.grad', [])
+                        self.observable.__setattr__(key + ".grad", [])
 
             else:
                 self.observable.__setattr__(k, [])
@@ -166,50 +169,49 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
             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':
-
+            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).item())
+                    self.observable.energy.append(np.mean(data).item())
                 else:
-                    self.observable.energy[-1] *= ibatch/(ibatch+1)
-                    self.observable.energy[-1] += np.mean(
-                        data).item()/(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):
@@ -220,12 +222,11 @@ 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):
         """Print the observalbe to csreen
@@ -236,23 +237,19 @@ 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):
         """Resample the wave function
@@ -265,39 +262,39 @@ 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()[
-                           :self.sampler.walkers.nwalkers]).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
+                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)
+                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, batchsize=None, hdf5_group='single_point'):
+    def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"):
         """Performs a single point calculatin
 
         Args:
@@ -309,21 +306,22 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'
             SimpleNamespace: contains the local energy, positions, ...
         """
 
-        log.info('')
-        log.info('  Single Point Calculation : {nw} walkers | {ns} steps',
-                 nw=self.sampler.walkers.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:
-
             #  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':
+            pos = 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
@@ -331,40 +329,32 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'
                 eloc = self.wf.local_energy(pos)
 
             else:
-                nbatch = int(np.ceil(len(pos)/batchsize))
+                nbatch = int(np.ceil(len(pos) / batchsize))
 
                 for ibatch in range(nbatch):
                     istart = ibatch * batchsize
-                    iend = min((ibatch+1) * batchsize, len(pos))
+                    iend = min((ibatch + 1) * batchsize, len(pos))
                     if ibatch == 0:
-                        eloc = self.wf.local_energy(
-                            pos[istart:iend, :])
+                        eloc = self.wf.local_energy(pos[istart:iend, :])
                     else:
-                        eloc = torch.cat((eloc, self.wf.local_energy(
-                            pos[istart:iend, :])))
+                        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)
+            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())
 
             # dump data to hdf5
             obs = SimpleNamespace(
-                pos=pos,
-                local_energy=eloc,
-                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
 
@@ -376,13 +366,16 @@ def save_checkpoint(self, epoch, loss):
             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)
+        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):
         """load a model/optmizer
@@ -394,10 +387,10 @@ 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):
@@ -412,7 +405,7 @@ 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=None, with_tqdm=True, hdf5_group="sampling_trajectory"):
         """Compute the local energy along a sampling trajectory
 
         Args:
@@ -422,8 +415,8 @@ 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)
@@ -431,18 +424,15 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group='sampling_trajector
         ndim = pos.shape[-1]
         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:
             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):
@@ -476,52 +466,46 @@ def save_traj(self, fname, obs):
         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, batchsize=None, loss="variance"):
         raise NotImplementedError()
 
     def log_data(self):
         """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 fdf994c9..7562bc4d 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -2,8 +2,7 @@
 from types import SimpleNamespace
 
 import torch
-from qmctorch.utils import (DataLoader, Loss, OrthoReg, add_group_attr,
-                            dump_to_hdf5)
+from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
 
 from .. import log
 from .solver import Solver
@@ -20,9 +19,9 @@ def logd(rank, *args):
 
 
 class SolverMPI(Solver):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Distributed QMC solver
 
         Args:
@@ -34,18 +33,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.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(
+        self,
+        nepoch,
+        batchsize=None,
+        loss="energy",
+        clip_loss=False,
+        grad="manual",
+        hdf5_group="wf_opt",
+        num_threads=1,
+        chkpt_every=None,
+    ):
         """Run the optimization
 
         Args:
@@ -63,21 +70,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.walkers.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()
@@ -87,8 +100,7 @@ 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)
+        self.loss.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
         self.ortho_loss = OrthoReg()
@@ -96,7 +108,7 @@ def run(self, nepoch, batchsize=None, loss='energy',
         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:
@@ -119,27 +131,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]
 
         # create the data loader
         # self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(
-            pos, batch_size=batchsize, pin_memory=self.cuda)
-        min_loss = 1E3
+        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
@@ -153,16 +162,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:
@@ -179,8 +185,7 @@ 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
@@ -189,11 +194,11 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
         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=True, hdf5_group="single_point"):
         """Performs a single point calculation
 
         Args:
@@ -205,13 +210,17 @@ 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.walkers.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
+            ),
+        )
 
         # 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
@@ -220,46 +229,39 @@ 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':
+            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)
+            e, s, err = torch.mean(eloc), torch.var(eloc), 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 = hvd.allgather(eloc, name="local_energies")
+            e, s, err = (
+                torch.mean(eloc_all),
+                torch.var(eloc_all),
+                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
+                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
 
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 67e0052b..10f8e555 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -1,10 +1,14 @@
 """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 .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,
@@ -12,25 +16,44 @@
 #                         plot_integrated_autocorrelation_time,
 #                         plot_walkers_traj)
 
-from .stat_utils import (blocking, correlation_coefficient,
-                         integrated_autocorrelation_time)
-from .torch_utils import (DataSet, DataLoader, Loss, OrthoReg, fast_power,
-                          set_torch_double_precision,
-                          set_torch_single_precision,
-                          diagonal_hessian, gradients)
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    integrated_autocorrelation_time,
+)
+from .torch_utils import (
+    DataSet,
+    DataLoader,
+    Loss,
+    OrthoReg,
+    fast_power,
+    set_torch_double_precision,
+    set_torch_single_precision,
+    diagonal_hessian,
+    gradients,
+)
 
 # __all__ = ['plot_energy', 'plot_data', 'plot_block',
 #            'plot_walkers_traj',
 #            'plot_correlation_time',
 #            'plot_autocorrelation',
-__all__ = ['set_torch_double_precision',
-           'set_torch_single_precision',
-           'DataSet', 'Loss', 'OrthoReg', 'DataLoader',
-           'dump_to_hdf5', 'load_from_hdf5',
-           'bytes2str',
-           'register_extra_attributes',
-           'fast_power',
-           'InterpolateMolecularOrbitals',
-           'InterpolateAtomicOrbitals',
-           'btrace', 'bdet2', 'bproj',
-           'diagonal_hessian', 'gradients']
+__all__ = [
+    "set_torch_double_precision",
+    "set_torch_single_precision",
+    "DataSet",
+    "Loss",
+    "OrthoReg",
+    "DataLoader",
+    "dump_to_hdf5",
+    "load_from_hdf5",
+    "bytes2str",
+    "register_extra_attributes",
+    "fast_power",
+    "InterpolateMolecularOrbitals",
+    "InterpolateAtomicOrbitals",
+    "btrace",
+    "bdet2",
+    "bproj",
+    "diagonal_hessian",
+    "gradients",
+]
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index 50f5d5bf..a87c7be6 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -44,33 +44,34 @@ def bdet2(M):
 
 
 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)
 
         # 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/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index cff485a3..4ce2dc54 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -9,16 +9,19 @@
 
 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 +33,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 +50,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,12 +66,8 @@ 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)
+            parent_obj.__setattr__(grp_name, SimpleNamespace())
+        load_object(grp, parent_obj.__getattribute__(grp_name), grp_name)
     except:
         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)
 
@@ -314,8 +314,7 @@ def insert_tuple(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
     # fix for type torch.Tensor
-    obj = [o.numpy() if isinstance(
-        o, torch.Tensor) else o for o in obj]
+    obj = [o.numpy() if isinstance(o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 
@@ -327,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)
 
 
@@ -378,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):
@@ -391,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()
 
 
@@ -408,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))
@@ -434,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)
 
@@ -465,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()
@@ -478,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..9f19d833 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -8,22 +8,21 @@
 # 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):
-
-        if method == 'irreg':
-            n = kwargs['n'] if 'n' in kwargs else 6
+    def __call__(self, pos, method="irreg", orb="occupied", **kwargs):
+        if method == "irreg":
+            n = kwargs["n"] if "n" in kwargs else 6
             return self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
 
-        elif method == 'reg':
-            rstr, bstr = 'resolution', 'border_length'
+        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.
+            blength = kwargs[bstr] if bstr in kwargs else 2.0
             return self.interpolate_mo_reg_grid(pos, res, blength, orb)
 
     def get_mo_max_index(self, orb):
@@ -36,14 +35,12 @@ def get_mo_max_index(self, orb):
             ValueError: if orb not valid
         """
 
-        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.
@@ -57,26 +54,25 @@ def interpolate_mo_irreg_grid(self, pos, n, orb):
         """
         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):
                 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()
+                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, res, blength, orb):
         """Interpolate the mo occupied in the configs.
 
         Args:
@@ -88,29 +84,26 @@ 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]
+                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
@@ -127,22 +120,30 @@ def __call__(self, pos, n=6, length=2):
             torch.tensor: Interpolated values
         """
 
-        if not hasattr(self, 'interp_func'):
+        if not hasattr(self, "interp_func"):
             t0 = time()
             self.get_interpolator()
-            print('___', time()-t0)
+            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))
 
@@ -157,37 +158,42 @@ def get_interpolator(self, n=6, length=2):
         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):
             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)]
+        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, border_length=2.):
+def get_boundaries(atomic_positions, border_length=2.0):
     """Computes the boundaries of the structure
 
     Args:
@@ -213,7 +219,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,7 +228,7 @@ 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, resolution=0.1, border_length=2.0):
     """Computes a regular grid points from the atomic positions
 
     Args:
@@ -233,9 +240,8 @@ def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.):
         (np.ndarray, np.ndarray, mp.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])
@@ -257,16 +263,13 @@ def interpolator_reg_grid(func, x, y, z):
         callable: 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):
@@ -280,32 +283,31 @@ 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
+    return x // 2 * 2 == x
 
 
 def logspace(n, length):
     """returns a 1d array of logspace between -length and +length."""
-    k = np.log(length+1)/np.log(10)
+    k = np.log(length + 1) / np.log(10)
     if is_even(n):
-        x = np.logspace(0.01, k, n//2)-1
+        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.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, n=6, length=2.0, border_length=2.0):
     """Computes a logarithmic grid
 
     Args:
@@ -318,14 +320,11 @@ def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
         np.ndanrray: 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
@@ -347,9 +346,7 @@ def interpolator_irreg_grid(func, grid_pts):
         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):
@@ -363,5 +360,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
+    nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
     return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim)))
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 18d70ec8..10f3b61a 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -2,9 +2,12 @@
 import numpy as np
 from matplotlib import cm
 
-from .stat_utils import (blocking, correlation_coefficient,
-                         fit_correlation_coefficient,
-                         integrated_autocorrelation_time)
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    fit_correlation_coefficient,
+    integrated_autocorrelation_time,
+)
 
 
 def plot_energy(local_energy, e0=None, show_variance=False):
@@ -27,21 +30,22 @@ def plot_energy(local_energy, e0=None, show_variance=False):
     variance = np.array([np.var(e) 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, energy - variance, energy + variance, 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()
@@ -60,12 +64,12 @@ 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, walkers="mean"):
     """Plot the trajectory of all the individual walkers
 
     Args:
@@ -77,28 +81,26 @@ def plot_walkers_traj(eloc, walkers='mean'):
     celoc /= np.arange(1, nstep + 1)
 
     if walkers is not None:
-
-        if walkers == 'all':
-            plt.plot(eloc, 'o', alpha=max(
-                1 / nwalkers, 1E-2), 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()
 
@@ -116,18 +118,18 @@ def plot_correlation_coefficient(eloc, size_max=100):
     """
 
     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()
 
@@ -152,11 +154,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,23 +164,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, block_size, walkers="mean"):
     """Plot the blocked energy values
 
     Args:
@@ -192,24 +192,24 @@ def plot_blocking_energy(eloc, block_size, walkers='mean'):
         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)
@@ -233,8 +233,8 @@ 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()
 
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 11c2dc3d..38f2e4bc 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -13,7 +13,7 @@ def blocking(x, block_size, expand=False):
     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:
@@ -33,7 +33,7 @@ def correlation_coefficient(x, norm=True):
     N = x.shape[0]
     xm = x - x.mean(0)
 
-    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1:]
+    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1 :]
 
     if norm:
         c /= c[0]
@@ -48,7 +48,7 @@ def integrated_autocorrelation_time(correlation_coeff, size_max):
         correlation_coeff (np.ndarray): coeff size Nsample,Nexp
         size_max (int): max size
     """
-    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):
@@ -68,7 +68,7 @@ def fit_exp(x, y):
         def func(x, tau):
             return np.exp(-x / tau)
 
-        popt, pcov = curve_fit(func, x, y, p0=(1.))
+        popt, pcov = 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 b61c0d56..4050eeff 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -31,7 +31,6 @@ def fast_power(x, k, mask0=None, mask2=None):
     """
     kmax = 3
     if k.max() < kmax:
-
         out = x.clone()
 
         if mask0 is None:
@@ -72,10 +71,7 @@ def diagonal_hessian(out, inp, return_grads=False):
     """
     # 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()
@@ -85,11 +81,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]
 
@@ -101,7 +95,6 @@ def diagonal_hessian(out, inp, return_grads=False):
 
 
 class DataSet(Dataset):
-
     def __init__(self, data):
         """Creates a torch data set
 
@@ -130,8 +123,7 @@ def __getitem__(self, index):
         return self.data[index, :]
 
 
-class DataLoader():
-
+class DataLoader:
     def __init__(self, data, batch_size, pin_memory=False):
         """Simple DataLoader to replace toch data loader
 
@@ -147,7 +139,7 @@ def __init__(self, data, batch_size, pin_memory=False):
             self.dataset = data
 
         self.len = len(data)
-        self.nbatch = ceil(self.len/batch_size)
+        self.nbatch = ceil(self.len / batch_size)
         self.count = 0
         self.batch_size = batch_size
 
@@ -156,13 +148,14 @@ def __iter__(self):
         return self
 
     def __next__(self):
-        if self.count < self.nbatch-1:
-            out = self.dataset[self.count *
-                               self.batch_size:(self.count+1)*self.batch_size]
+        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:]
+        elif self.count == self.nbatch - 1:
+            out = self.dataset[self.count * self.batch_size :]
             self.count += 1
             return out
         else:
@@ -170,12 +163,7 @@ def __next__(self):
 
 
 class Loss(nn.Module):
-
-    def __init__(
-            self,
-            wf,
-            method='energy',
-            clip=False):
+    def __init__(self, wf, method="energy", clip=False):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -205,11 +193,10 @@ def __init__(
         self.clip_num_std = 5
 
         # select loss function
-        self.loss_fn = {'energy': torch.mean,
-                        'variance': torch.var}[method]
+        self.loss_fn = {"energy": torch.mean, "variance": torch.var}[method]
 
         # init values of the weights
-        self.weight = {'psi': None, 'psi0': None}
+        self.weight = {"psi": None, "psi0": None}
 
     def forward(self, pos, no_grad=False, deactivate_weight=False):
         """Computes the loss
@@ -227,7 +214,6 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
 
         # check if grads are requested
         with self.get_grad_mode(no_grad):
-
             # compute local eneergies
             local_energies = self.wf.local_energy(pos)
 
@@ -263,47 +249,41 @@ def get_clipping_mask(self, 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)
+            mask = (local_energies < emax) & (local_energies > emin)
         else:
-            mask = torch.ones_like(
-                local_energies).type(torch.bool)
+            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
+        done at every step
         """
 
-        local_use_weight = self.use_weight * \
-            (not deactivate_weight)
+        local_use_weight = self.use_weight * (not deactivate_weight)
 
         if local_use_weight:
-
             # computes the weights
-            self.weight['psi'] = self.wf(pos)
+            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'])
+            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 = (self.weight["psi"] / self.weight["psi0"]) ** 2
                 w /= w.sum()  # should we multiply by the number of elements ?
 
             return w
 
         else:
-            return 1.
+            return 1.0
 
 
 class OrthoReg(nn.Module):
-    '''add a penalty to make matrice orthgonal.'''
+    """add a penalty to make matrice orthgonal."""
 
     def __init__(self, alpha=0.1):
         """Add a penalty loss to keep the MO orthogonalized
@@ -316,6 +296,4 @@ def __init__(self, alpha=0.1):
 
     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]))
+        return self.alpha * torch.norm(W.mm(W.transpose(0, 1)) - torch.eye(W.shape[0]))
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 6d4e27de..6078939e 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,11 +1,13 @@
-__all__ = ['WaveFunction', 'SlaterJastrow']
+__all__ = ["WaveFunction", "SlaterJastrow"]
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterOrbitalDependentJastrow']
+
+__all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
 
 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
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 90bac67e..70fd8ee3 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,11 +1,9 @@
-
 import torch
 from torch import nn
 from functools import reduce
 
 
 class CombineJastrow(nn.Module):
-
     def __init__(self, jastrow):
         """[summary]
 
@@ -53,69 +51,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:
@@ -125,15 +121,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:
@@ -144,25 +140,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/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 3b6fbd3a..9c8a776a 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -1,12 +1,13 @@
 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):
         """Computes the electron-electron distances
 
@@ -36,9 +37,9 @@ 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):
         """Compute the pairwise distance between the electrons
@@ -79,7 +80,6 @@ def forward(self, input, derivative=0):
                 return dist
 
         elif derivative == 1:
-
             der_dist = self.get_der_distance(input_, dist)
 
             if self.scale:
@@ -88,15 +88,13 @@ 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
 
@@ -113,14 +111,11 @@ 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_)
@@ -143,11 +138,9 @@ 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
@@ -168,16 +161,13 @@ 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):
@@ -191,8 +181,7 @@ 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
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index ea4a67f4..bba5e66b 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,12 +1,13 @@
 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 ElectronNucleiDistance(nn.Module):
-
     def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
         """Computes the electron-nuclei distances
 
@@ -67,21 +68,18 @@ 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
 
@@ -101,9 +99,8 @@ 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):
@@ -121,14 +118,13 @@ 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):
@@ -142,5 +138,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..070b6f32 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -16,7 +16,7 @@ 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):
@@ -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 3c165029..98540879 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -1,4 +1,6 @@
-from .jastrow_factor_electron_electron import JastrowFactorElectronElectron as JastrowFactor
+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
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 6b121115..d88d7f1a 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -5,14 +5,17 @@
 
 
 class JastrowFactorElectronElectron(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 orbital_dependent_kernel=False,
-                 number_of_orbitals=None,
-                 scale=False, scale_factor=0.6,
-                 cuda=False):
+    def __init__(
+        self,
+        mol,
+        jastrow_kernel,
+        kernel_kwargs={},
+        orbital_dependent_kernel=False,
+        number_of_orbitals=None,
+        scale=False,
+        scale_factor=0.6,
+        cuda=False,
+    ):
         """Electron-Electron Jastrow factor.
 
         .. math::
@@ -38,28 +41,35 @@ def __init__(self, mol,
         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:
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
-                mol.nup, mol.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(
-                mol.nup, mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -71,11 +81,10 @@ def get_mask_tri_up(self):
         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
@@ -112,13 +121,15 @@ 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)
+            return self.extract_tri_up(self.edist(pos, derivative=2)).view(
+                nbatch, 3, -1
+            )
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -156,21 +167,20 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -188,9 +198,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
@@ -200,9 +208,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
@@ -228,8 +234,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]
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..b9407339 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
@@ -5,11 +5,16 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self,  nup, ndown, cuda,
-                 size1=16, size2=8,
-                 activation=torch.nn.Sigmoid(),
-                 include_cusp_weight=True):
+    def __init__(
+        self,
+        nup,
+        ndown,
+        cuda,
+        size1=16,
+        size2=8,
+        activation=torch.nn.Sigmoid(),
+        include_cusp_weight=True,
+    ):
         """Defines a fully connected jastrow factors."""
 
         super().__init__(nup, ndown, cuda)
@@ -20,13 +25,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)
 
@@ -41,13 +46,12 @@ def get_var_weight(self):
 
         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:
@@ -63,16 +67,29 @@ def get_static_weight(self):
             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
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..7203719d 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
@@ -5,7 +5,6 @@
 
 
 class JastrowKernelElectronElectronBase(nn.Module):
-
     def __init__(self, nup, ndown, cuda, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
 
@@ -18,9 +17,9 @@ 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
 
@@ -71,7 +70,6 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -101,12 +99,10 @@ 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
 
@@ -134,10 +130,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..eddeeffd 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, ndown, cuda, w=1.0):
         """Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -26,9 +25,8 @@ 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
@@ -40,22 +38,35 @@ def get_static_weight(self):
             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.
+        """Get the jastrow kernel.
 
         .. math::
             B_{ij} = \\frac{w_0 r_{i,j}}{1+w r_{i,j}}
@@ -99,11 +110,11 @@ 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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -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..e3f8bb93 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
@@ -6,11 +6,7 @@
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self, nup, ndown, cuda,
-                 order=2,
-                 weight_a=None,
-                 weight_b=None):
+    def __init__(self, nup, ndown, cuda, order=2, weight_a=None, weight_b=None):
         """Computes a polynomial Pade-Jastrow factor
 
         .. math::
@@ -51,16 +47,29 @@ def get_static_weight(self):
             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
@@ -75,7 +84,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 +97,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.
+        """Get the jastrow kernel.
 
         .. math::
 
@@ -191,12 +200,13 @@ 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
 
@@ -213,7 +223,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):
@@ -245,7 +255,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
@@ -277,10 +286,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 bbb814b9..8c4b6053 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -1,3 +1,5 @@
-from .jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei as JastrowFactor
+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
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 2a5482bd..3d296aa5 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
@@ -8,11 +8,7 @@
 
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -34,9 +30,9 @@ def __init__(self, mol,
         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)
@@ -44,24 +40,20 @@ def __init__(self, mol,
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(mol.nup, mol.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
@@ -77,11 +69,10 @@ def get_mask_tri_up(self):
         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
@@ -121,8 +112,7 @@ 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):
         """Assemle the different distances for easy calculations
@@ -177,9 +167,9 @@ def assemble_dist_deriv(self, pos, derivative=1):
     def _to_device(self):
         """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)
@@ -221,9 +211,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)
@@ -232,23 +223,21 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -264,7 +253,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)
@@ -289,7 +277,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)
@@ -297,8 +284,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]
@@ -330,8 +316,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])
@@ -375,7 +360,7 @@ 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):
         """Compute the second derivative of the jastrow factor automatically.
@@ -387,24 +372,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..7810c835 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -1,3 +1,5 @@
 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
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..96111e7d 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,10 +1,11 @@
 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.
 
@@ -60,15 +61,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..ad0ed97c 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,9 +1,10 @@
 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, ndown, atomic_pos, cuda):
         """Defines a fully connected jastrow factors."""
 
@@ -17,9 +18,9 @@ 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()
 
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..b2042712 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,7 +5,6 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
-
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base Class for the elec-elec-nuc jastrow kernel
 
@@ -26,9 +25,9 @@ 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):
@@ -58,16 +57,14 @@ def compute_derivative(self, r, dr):
         return out
 
     def compute_second_derivative(self, r, dr, d2r):
-        """Get the elements of the pure 2nd derivative of the jastrow kernels.
-        """
+        """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
 
@@ -92,20 +89,19 @@ def _hess(val, pos, device):
             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/jastrow_factor_electron_nuclei.py b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
index 1bae2032..b376d6ad 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -4,11 +4,7 @@
 
 
 class JastrowFactorElectronNuclei(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         r"""Base class for two el-nuc jastrow of the form:
 
         .. math::
@@ -28,9 +24,9 @@ def __init__(self, mol,
         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)
@@ -38,16 +34,15 @@ def __init__(self, mol,
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(mol.nup,  mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -89,21 +84,20 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -119,14 +113,10 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
         """
         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):
@@ -144,12 +134,11 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
         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/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
index beefdc28..d9e5bd69 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,8 +5,7 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
+    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
         r"""Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -31,7 +30,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
         self.requires_autograd = True
 
     def forward(self, x):
-        """ Get the jastrow kernel.
+        """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..d0890f3e 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
@@ -4,7 +4,6 @@
 
 
 class JastrowKernelElectronNucleiBase(nn.Module):
-
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base class for the elec-nuc jastrow factor
 
@@ -27,9 +26,9 @@ 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):
@@ -73,7 +72,6 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -108,13 +106,11 @@ 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
 
@@ -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..ca0b4159 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, ndown, atomic_pos, cuda, w=1.0):
         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.
+        """Get the jastrow kernel.
         .. math::
             B_{ij} = \frac{b r_{i,j}}{1+b'r_{i,j}}
 
@@ -70,11 +70,11 @@ 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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -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/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 88be8258..35a8f7f9 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -19,11 +19,10 @@ def ElecElecGraph(nelec, nup):
 
 
 def get_elec_elec_edges(nelec):
-    """Compute the edge index of the electron-electron graph.
-    """
+    """Compute the edge index of the electron-electron graph."""
     ee_edges = ([], [])
-    for i in range(nelec-1):
-        for j in range(i+1, nelec):
+    for i in range(nelec - 1):
+        for j in range(i + 1, nelec):
             ee_edges[0].append(i)
             ee_edges[1].append(j)
 
@@ -34,8 +33,7 @@ def get_elec_elec_edges(nelec):
 
 
 def get_elec_elec_ndata(nelec, nup):
-    """Compute the node data of the elec-elec graph
-    """
+    """Compute the node data of the elec-elec graph"""
 
     ee_ndata = []
     for i in range(nelec):
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 0d6f0f72..0cb22dc8 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -16,21 +16,20 @@ def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
     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)
+        natoms, atom_types, atomic_features, nelec, nup
+    )
     return graph
 
 
 def get_elec_nuc_edges(natoms, nelec):
-    """Compute the edge index of the electron-nuclei graph.
-    """
+    """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[1].append(natoms + j)
 
-            en_edges[0].append(natoms+j)
+            en_edges[0].append(natoms + j)
             en_edges[1].append(i)
 
     # for i in range(natoms-1):
@@ -40,9 +39,8 @@ def get_elec_nuc_edges(natoms, nelec):
     return en_edges
 
 
-def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
-    """Compute the node data of the elec-elec graph
-    """
+def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
+    """Compute the node data of the elec-elec graph"""
 
     en_ndata = []
     embed_number = 0
@@ -65,22 +63,20 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
         if i < nup:
             en_ndata.append(embed_number)
         else:
-            en_ndata.append(embed_number+1)
+            en_ndata.append(embed_number + 1)
 
     return torch.LongTensor(en_ndata)
 
 
 def get_atomic_features(atom_type, atomic_features):
-    """Get the atomic features requested.
-    """
+    """Get the atomic features requested."""
     if atom_type is not None:
         data = element(atom_type)
-        feat = [getattr(data, feat)
-                for feat in atomic_features]
+        feat = [getattr(data, feat) for feat in atomic_features]
     else:
         feat = []
         for atf in atomic_features:
-            if atf == 'atomic_number':
+            if atf == "atomic_number":
                 feat.append(-1)
             else:
                 feat.append(0)
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index e74a5a9d..a2c409c1 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -11,14 +11,16 @@
 
 
 class JastrowFactorGraph(nn.Module):
-
-    def __init__(self, mol,
-                 ee_model=MGCNPredictor,
-                 ee_model_kwargs={},
-                 en_model=MGCNPredictor,
-                 en_model_kwargs={},
-                 atomic_features=["atomic_number"],
-                 cuda=False):
+    def __init__(
+        self,
+        mol,
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+    ):
         """Graph Neural Network Jastrow Factor
 
         Args:
@@ -42,14 +44,13 @@ def __init__(self, mol,
         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.atom_types = mol.atoms
         self.atomic_features = atomic_features
-        self.atoms = torch.as_tensor(
-            mol.atom_coords).to(self.device)
+        self.atoms = torch.as_tensor(mol.atom_coords).to(self.device)
         self.natoms = self.atoms.shape[0]
 
         self.requires_autograd = True
@@ -58,10 +59,8 @@ def __init__(self, mol,
         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)
+        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
@@ -70,15 +69,16 @@ def __init__(self, mol,
 
         # instantiate the en model
         en_model_kwargs["num_node_types"] = 2 + self.natoms
-        en_model_kwargs["num_edge_types"] = 2*self.natoms
+        en_model_kwargs["num_edge_types"] = 2 * self.natoms
         self.en_model = en_model(**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)
+        self.en_graph = ElecNucGraph(
+            self.natoms, self.atom_types, self.atomic_features, self.nelec, self.nup
+        )
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -105,8 +105,8 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -115,22 +115,16 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -142,7 +136,9 @@ def forward(self, pos, derivative=0, sum_grad=True):
             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)
+            return self._get_hess_vals(
+                pos, ee_kernel, en_kernel, sum_grad=sum_grad, return_all=True
+            )
 
     def _get_val(self, ee_kernel, en_kernel):
         """Get the jastrow values.
@@ -166,18 +162,19 @@ def _get_grad_vals(self, pos, ee_kernel, en_kernel, sum_grad):
 
         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)
+        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, ee_kernel, en_kernel, sum_grad=False, return_all=False):
+    def _get_hess_vals(
+        self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=False
+    ):
         """Get the hessian values
 
         Args:
@@ -192,10 +189,13 @@ def _get_hess_vals(self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=F
 
         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]
+        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)
@@ -203,18 +203,19 @@ def _get_hess_vals(self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=F
         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]
+            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)
+        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)
+            grad_val = grad_val.detach().reshape(nbatch, self.nelec, 3).transpose(1, 2)
 
             if sum_grad:
                 grad_val = grad_val.sum(1)
@@ -230,11 +231,10 @@ def get_mask_tri_up(self):
         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
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
index 018030bf..871927d6 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -57,11 +57,11 @@ def get_edge_types(self, edges):
         dict
             Mapping 'type' to the computed edge types.
         """
-        node_type1 = edges.src['type']
-        node_type2 = edges.dst['type']
+        node_type1 = edges.src["type"]
+        node_type2 = edges.dst["type"]
         return {
-            'type': node_type1 * node_type2 +
-            (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+            "type": node_type1 * node_type2
+            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
         }
 
     def forward(self, g, node_types):
@@ -80,9 +80,9 @@ def forward(self, g, node_types):
             Edge representations.
         """
         g = g.local_var()
-        g.ndata['type'] = node_types
+        g.ndata["type"] = node_types
         g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata['type'])
+        return self.embed(g.edata["type"])
 
 
 class VEConv(nn.Module):
@@ -109,7 +109,7 @@ def __init__(self, dist_feats, feats, update_edge=True):
         self.update_dists = nn.Sequential(
             nn.Linear(dist_feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats)
+            nn.Linear(feats, feats),
         )
         if update_edge:
             self.update_edge_feats = nn.Linear(feats, feats)
@@ -151,12 +151,11 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
             edge_feats = self.update_edge_feats(edge_feats)
 
         g = g.local_var()
-        g.ndata.update({'hv': node_feats})
-        g.edata.update({'dist': expanded_dists, 'he': edge_feats})
-        g.update_all(fn.u_mul_e('hv', 'dist', 'm_0'),
-                     fn.sum('m_0', 'hv_0'))
-        g.update_all(fn.copy_e('he', 'm_1'), fn.sum('m_1', 'hv_1'))
-        node_feats = g.ndata.pop('hv_0') + g.ndata.pop('hv_1')
+        g.ndata.update({"hv": node_feats})
+        g.edata.update({"dist": expanded_dists, "he": edge_feats})
+        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
+        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
+        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
 
         return node_feats, edge_feats
 
@@ -185,11 +184,10 @@ def __init__(self, feats, dist_feats):
         self.project_out_node_feats = nn.Sequential(
             nn.Linear(feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats)
+            nn.Linear(feats, feats),
         )
         self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats),
-            nn.Softplus(beta=0.5, threshold=14)
+            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
         )
 
     def reset_parameters(self):
@@ -224,7 +222,8 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
         """
         new_node_feats = self.project_in_node_feats(node_feats)
         new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists)
+            g, new_node_feats, edge_feats, expanded_dists
+        )
         new_node_feats = self.project_out_node_feats(new_node_feats)
         node_feats = node_feats + new_node_feats
 
@@ -257,8 +256,15 @@ class MGCNGNN(nn.Module):
         Difference between two adjacent centers in RBF expansion. Default to 0.1.
     """
 
-    def __init__(self, feats=128, n_layers=3, num_node_types=100,
-                 num_edge_types=3000, cutoff=30., gap=0.1):
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=30.0,
+        gap=0.1,
+    ):
         super(MGCNGNN, self).__init__()
 
         self.node_embed = nn.Embedding(num_node_types, feats)
@@ -269,8 +275,7 @@ def __init__(self, feats=128, n_layers=3, num_node_types=100,
 
         self.gnn_layers = nn.ModuleList()
         for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(
-                feats, len(self.rbf.centers)))
+            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
 
     def reset_parameters(self):
         """Reinitialize model parameters."""
@@ -305,7 +310,6 @@ def forward(self, g, node_types, edge_dists):
 
         all_layer_node_feats = [node_feats]
         for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(
-                g, node_feats, edge_feats, expanded_dists)
+            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
             all_layer_node_feats.append(node_feats)
         return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
index abaf7153..9f710fd3 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -40,26 +40,41 @@ class MGCNPredictor(nn.Module):
         Size for hidden representations in the output MLP predictor. Default to 64.
     """
 
-    def __init__(self, feats=128, n_layers=3, classifier_hidden_feats=64,
-                 n_tasks=1, num_node_types=100, num_edge_types=3000,
-                 cutoff=5.0, gap=1.0, predictor_hidden_feats=64):
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        classifier_hidden_feats=64,
+        n_tasks=1,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=5.0,
+        gap=1.0,
+        predictor_hidden_feats=64,
+    ):
         super(MGCNPredictor, self).__init__()
 
         if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print('classifier_hidden_feats is deprecated and will be removed in the future, '
-                  'use predictor_hidden_feats instead')
+            print(
+                "classifier_hidden_feats is deprecated and will be removed in the future, "
+                "use predictor_hidden_feats instead"
+            )
             predictor_hidden_feats = classifier_hidden_feats
 
-        self.gnn = MGCNGNN(feats=feats,
-                           n_layers=n_layers,
-                           num_node_types=num_node_types,
-                           num_edge_types=num_edge_types,
-                           cutoff=cutoff,
-                           gap=gap)
-        self.readout = MLPNodeReadout(node_feats=(n_layers + 1) * feats,
-                                      hidden_feats=predictor_hidden_feats,
-                                      graph_feats=n_tasks,
-                                      activation=nn.Softplus(beta=1, threshold=20))
+        self.gnn = MGCNGNN(
+            feats=feats,
+            n_layers=n_layers,
+            num_node_types=num_node_types,
+            num_edge_types=num_edge_types,
+            cutoff=cutoff,
+            gap=gap,
+        )
+        self.readout = MLPNodeReadout(
+            node_feats=(n_layers + 1) * feats,
+            hidden_feats=predictor_hidden_feats,
+            graph_feats=n_tasks,
+            activation=nn.Softplus(beta=1, threshold=20),
+        )
 
     def forward(self, g, node_types, edge_dists):
         """Graph-level regression/soft classification.
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index 6db28ce9..d2f69a2a 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,29 +1,34 @@
-
 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, mol,
-                 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:
@@ -43,7 +48,7 @@ def __init__(self, mol,
         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,35 +56,34 @@ def __init__(self, mol,
 
         self.requires_autograd = True
 
-        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))
+        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)
 
     def __repr__(self):
         """representation of the jastrow factor"""
         out = []
-        for k in ['ee', 'en', 'een']:
+        for k in ["ee", "en", "een"]:
             if self.jastrow_kernel_dict[k] is not None:
-                out.append(k + " -> " +
-                           self.jastrow_kernel_dict[k].__name__)
+                out.append(k + " -> " + self.jastrow_kernel_dict[k].__name__)
 
         return " + ".join(out)
 
@@ -105,69 +109,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:
@@ -177,15 +179,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:
@@ -196,25 +198,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..99929c5d 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -2,13 +2,16 @@
 from torch import nn
 
 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
 
 
 class AtomicOrbitals(nn.Module):
-
     def __init__(self, mol, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -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,94 @@ 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)
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
             self._to_device()
 
     def __repr__(self):
         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)
+        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):
         """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, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
+    ):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -161,10 +174,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 +187,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,7 +200,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, 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
@@ -258,9 +270,7 @@ 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])
 
@@ -296,10 +306,9 @@ 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)
 
@@ -320,12 +329,12 @@ 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
@@ -361,13 +370,11 @@ 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):
@@ -385,8 +392,7 @@ 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
@@ -405,13 +411,19 @@ 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)
 
@@ -432,13 +444,16 @@ 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
@@ -458,14 +473,16 @@ 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)
 
@@ -488,15 +505,25 @@ def _off_diag_hessian_kernel(self, R, dR, d2R, d2mR, Y, dY, d2Y, d2mY):
 
         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
@@ -522,19 +549,19 @@ def _compute_all_ao_values(self, 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):
         """Computes the positions/distance bewteen elec/orb
@@ -553,8 +580,10 @@ 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):
         """Computes the positions/distance bewteen elec/atoms
@@ -570,11 +599,10 @@ 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
 
@@ -589,9 +617,9 @@ 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
 
@@ -618,6 +646,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 d3a7dbd3..b1f124ad 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -3,7 +3,6 @@
 
 
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
-
     def __init__(self, mol, backflow, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -16,7 +15,9 @@ def __init__(self, mol, backflow, cuda=False):
         dtype = torch.get_default_dtype()
         self.backflow_trans = backflow
 
-    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
+    def forward(
+        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
+    ):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -68,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
@@ -81,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)
@@ -96,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
@@ -179,7 +179,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:
@@ -194,8 +196,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)
@@ -221,14 +222,13 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
         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)
@@ -254,13 +254,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)
@@ -269,16 +275,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)
 
@@ -295,7 +300,6 @@ def _process_position(self, pos):
                                         (Nbatch, Nelec, Norb)
         """
         if self.backflow_trans.orbital_dependent:
-
             # get the elec-atom vectrors/distances
             xyz, r = self._elec_ao_dist(pos)
 
@@ -307,14 +311,15 @@ def _process_position(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))
+            return (
+                xyz.repeat_interleave(self.nshells, dim=2),
+                r.repeat_interleave(self.nshells, dim=2),
+            )
 
     def _elec_atom_dist(self, pos):
         """Computes the positions/distance bewteen elec/atoms
@@ -333,11 +338,10 @@ 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))
+        r = torch.sqrt((xyz * xyz).sum(3))
 
         return xyz, r
 
@@ -367,15 +371,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/atomic_orbitals_orbital_dependent_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
index 239bc732..50320839 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
 
@@ -16,12 +17,16 @@ 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):
+        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
@@ -177,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:
@@ -192,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)
@@ -219,14 +224,13 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
         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)
@@ -252,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)
@@ -267,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)
 
@@ -329,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/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 30d42d26..79ed8cee 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -6,8 +6,14 @@
 
 
 class BackFlowTransformation(nn.Module):
-
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, orbital_dependent=False, cuda=False):
+    def __init__(
+        self,
+        mol,
+        backflow_kernel,
+        backflow_kernel_kwargs={},
+        orbital_dependent=False,
+        cuda=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
@@ -23,21 +29,19 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, orbital_depe
 
         if self.orbital_dependent:
             self.backflow_kernel = OrbitalDependentBackFlowKernel(
-                backflow_kernel, backflow_kernel_kwargs, mol, cuda)
+                backflow_kernel, backflow_kernel_kwargs, mol, cuda
+            )
         else:
-            self.backflow_kernel = backflow_kernel(mol,
-                                                   cuda,
-                                                   **backflow_kernel_kwargs)
+            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')
+            self.device = torch.device("cuda")
 
     def forward(self, pos, derivative=0):
-
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -49,7 +53,8 @@ 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 _get_backflow(self, pos):
         """Computes the backflow transformation
@@ -84,18 +89,18 @@ 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):
         """Computes the orbital dependent backflow transformation
@@ -115,20 +120,21 @@ def _backflow_od(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 _get_backflow_derivative(self, pos):
         r"""Computes the derivative of the backflow transformation
@@ -187,8 +193,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)
@@ -204,21 +211,18 @@ 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)
@@ -260,8 +264,11 @@ def _backflow_derivative_od(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)
@@ -278,26 +285,23 @@ def _backflow_derivative_od(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
@@ -365,8 +369,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
@@ -394,13 +399,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
@@ -408,8 +416,7 @@ 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)
@@ -452,8 +459,11 @@ def _backflow_second_derivative_od(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
@@ -482,13 +492,16 @@ def _backflow_second_derivative_od(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
@@ -496,12 +509,10 @@ def _backflow_second_derivative_od(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/backflow/kernels/backflow_kernel_autodiff_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
index f4479acb..1ffb230c 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,11 +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] = 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):
         """Computes the kernel via autodiff
@@ -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..a898b236 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelBase(nn.Module):
-
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,9 +14,9 @@ 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):
         """Computes the desired values of the kernel
@@ -39,8 +38,7 @@ 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):
         """Computes the kernel via autodiff
@@ -51,8 +49,7 @@ 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):
         """Computes the first derivative of the kernel via autodiff
@@ -84,7 +81,6 @@ 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)
 
@@ -113,10 +109,7 @@ def _hess(val, ree):
             pos ([type]): [description]
         """
 
-        gval = grad(val,
-                    ree,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        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]
 
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..196da707 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -5,7 +5,6 @@
 
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
-
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -18,7 +17,7 @@ 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
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 18ce0a5a..1b562d13 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelInverse(BackFlowKernelBase):
-
     def __init__(self, mol, cuda=False):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -18,8 +17,7 @@ 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([1e-3]))  # .to(self.device)
 
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
@@ -36,7 +34,7 @@ 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):
         """Computes the derivative of the kernel function
@@ -52,8 +50,8 @@ 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):
         """Computes the derivative of the kernel function
@@ -69,5 +67,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..925dbd96 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelPowerSum(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,8 +14,8 @@ 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):
         """Computes the kernel via autodiff
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
index f090a2bd..5cbe7f5a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -4,13 +4,13 @@
 
 
 class BackFlowKernelSquare(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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 84e28e02..92f9eef9 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -3,7 +3,6 @@
 
 
 class OrbitalDependentBackFlowKernel(nn.Module):
-
     def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
         """Compute orbital dependent back flow kernel, i.e. the functions
         f(rij) where rij is the distance between electron i and j
@@ -18,12 +17,16 @@ 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
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index 4fcec886..b216bc94 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -6,7 +6,6 @@
 
 
 class OrbitalDependentBackFlowTransformation(nn.Module):
-
     def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """Transform the electorn coordinates into backflow coordinates.
         see : Orbital-dependent backflow wave functions for real-space quantum Monte Carlo
@@ -21,16 +20,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')
+            self.device = torch.device("cuda")
 
     def forward(self, pos, derivative=0):
-
         if derivative == 0:
             return self._backflow(pos)
 
@@ -42,7 +41,8 @@ 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):
         """Computes the backflow transformation
@@ -62,20 +62,21 @@ 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):
         r"""Computes the derivative of the backflow transformation
@@ -108,8 +109,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,26 +130,23 @@ 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
@@ -183,8 +184,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 +217,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 +234,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/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 77ee6990..8b7d5546 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -17,34 +17,30 @@ 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, bas_exp):
@@ -60,9 +56,10 @@ def norm_slater_spherical(bas_n, bas_exp):
     Returns:
         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(
+        [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)
 
 
 def norm_gaussian_spherical(bas_n, bas_exp):
@@ -81,13 +78,14 @@ def norm_gaussian_spherical(bas_n, bas_exp):
     from scipy.special import factorial2 as f2
 
     bas_n = torch.tensor(bas_n)
-    bas_n = bas_n + 1.
-    exp1 = 0.25 * (2. * bas_n + 1.)
+    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)
-    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi **
-                        0.5).type(torch.get_default_dtype())
+    A = torch.tensor(bas_exp) ** exp1
+    B = 2 ** (2.0 * bas_n + 3.0 / 2)
+    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi**0.5).type(
+        torch.get_default_dtype()
+    )
 
     return torch.sqrt(B / C) * A
 
@@ -108,23 +106,25 @@ def norm_slater_cartesian(a, b, c, n, exp):
     """
     from scipy.special import factorial2 as f2
 
-    lvals = a + b + c + n + 1.
+    lvals = a + b + c + n + 1.0
 
-    lfact = torch.as_tensor([np.math.factorial(int(2 * i))
-                             for i in lvals]).type(torch.get_default_dtype())
+    lfact = torch.as_tensor([np.math.factorial(int(2 * i)) for i in lvals]).type(
+        torch.get_default_dtype()
+    )
 
-    prefact = 4 * np.pi * lfact / ((2 * exp)**(2 * lvals + 1))
+    prefact = 4 * np.pi * lfact / ((2 * exp) ** (2 * lvals + 1))
 
-    num = torch.as_tensor(f2(2 * a.astype('int') - 1) *
-                          f2(2 * b.astype('int') - 1) *
-                          f2(2 * c.astype('int') - 1)
-                          ).type(torch.get_default_dtype())
+    num = torch.as_tensor(
+        f2(2 * a.astype("int") - 1)
+        * f2(2 * b.astype("int") - 1)
+        * f2(2 * c.astype("int") - 1)
+    ).type(torch.get_default_dtype())
 
-    denom = torch.as_tensor(
-        f2((2 * a + 2 * b + 2 * c + 1).astype('int')
-           )).type(torch.get_default_dtype())
+    denom = torch.as_tensor(f2((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):
@@ -143,14 +143,14 @@ def norm_gaussian_cartesian(a, b, c, exp):
 
     from scipy.special import factorial2 as f2
 
-    pref = torch.as_tensor((2 * exp / np.pi)**(0.75))
-    am1 = (2 * a - 1).astype('int')
-    x = (4 * exp)**(a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
+    pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
+    am1 = (2 * a - 1).astype("int")
+    x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
 
-    bm1 = (2 * b - 1).astype('int')
-    y = (4 * exp)**(b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
+    bm1 = (2 * b - 1).astype("int")
+    y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
 
-    cm1 = (2 * c - 1).astype('int')
-    z = (4 * exp)**(c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
+    cm1 = (2 * c - 1).astype("int")
+    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
 
     return (pref * x * y * z).type(torch.get_default_dtype())
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index e0070b9f..aa765cdd 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -2,8 +2,9 @@
 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, bas_n, bas_exp, xyz=None, derivative=0, sum_grad=True, sum_hess=True
+):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -48,48 +49,54 @@ def _first_derivative_kernel():
             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 """
+        """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():
         """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,21 +104,24 @@ 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)
+        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)
+    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):
+def radial_gaussian(
+    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
+):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -140,76 +150,83 @@ def _kernel():
         return rn * er
 
     def _first_derivative_kernel():
-
         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():
-
         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():
         """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
+    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)
+    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):
+def radial_gaussian_pure(
+    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
+):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -247,12 +264,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,23 +283,26 @@ 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)
+    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):
+def radial_slater_pure(
+    R, bas_n, bas_exp, xyz=None, derivative=0, sum_grad=True, sum_hess=True
+):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -318,14 +339,14 @@ def _first_derivative_kernel():
             return nabla_er
 
     def _second_derivative_kernel():
-
         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():
@@ -334,8 +355,11 @@ def _mixed_second_derivative_kernel():
 
         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,19 +369,24 @@ 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,
+    _kernel,
+    _first_derivative_kernel,
+    _second_derivative_kernel,
+    _mixed_second_derivative_kernel,
+):
     """Returns the data contained in derivative
 
     Args:
@@ -372,10 +401,12 @@ def return_required_data(derivative, _kernel,
 
     # prepare the output/kernel
     output = []
-    fns = [_kernel,
-           _first_derivative_kernel,
-           _second_derivative_kernel,
-           _mixed_second_derivative_kernel]
+    fns = [
+        _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..01127598 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -3,7 +3,6 @@
 
 
 class Harmonics:
-
     def __init__(self, type, **kwargs):
         """Compute spherical or cartesian harmonics and their derivatives
 
@@ -29,35 +28,30 @@ 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
 
@@ -82,18 +76,27 @@ def __call__(self, xyz, derivative=[0], sum_grad=True, sum_hess=True):
             torch.tensor -- Values or gradient of the spherical 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')
+            raise ValueError("Harmonics type should be cart or sph")
 
 
-def CartesianHarmonics(xyz, k, mask0, mask2, derivative=[0],
-                       sum_grad=True, sum_hess=True):
+def CartesianHarmonics(
+    xyz, k, mask0, mask2, derivative=[0], sum_grad=True, sum_hess=True
+):
     r"""Computes Real Cartesian Harmonics
 
     .. math::
@@ -119,7 +122,7 @@ def _kernel():
         return xyz_k.prod(-1)
 
     def _first_derivative_kernel():
-        km1 = k-1
+        km1 = k - 1
         km1[km1 < 0] = 0
 
         xyz_km1 = fast_power(xyz, km1)
@@ -143,12 +146,9 @@ 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
@@ -156,30 +156,29 @@ def _second_derivative_kernel():
             return torch.stack((d2x, d2y, d2z), dim=-1)
 
     def _mixed_second_derivative_kernel():
-        km1 = k-1
+        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:
@@ -207,23 +206,22 @@ def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
     """
     if not sum_hess:
         raise NotImplementedError(
-            'SphericalHarmonics cannot return individual component of the laplacian')
+            "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)
 
 
@@ -248,42 +246,39 @@ 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
 
@@ -309,28 +304,27 @@ 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
 
 
@@ -374,6 +368,7 @@ def _lap_spherical_harmonics_l0(xyz):
     """
     return torch.zeros_like(xyz[..., 0])
 
+
 # =============== L1
 
 
@@ -407,7 +402,7 @@ 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):
@@ -427,22 +422,38 @@ 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))
+        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):
@@ -459,7 +470,8 @@ 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
 
@@ -481,16 +493,18 @@ 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):
@@ -513,17 +527,30 @@ 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):
@@ -550,39 +577,64 @@ 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))
+        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):
@@ -607,15 +659,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 c0d3aa9e..c89489b6 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -2,9 +2,7 @@
 
 
 class OrbitalConfigurations:
-
     def __init__(self, mol):
-
         self.nup = mol.nup
         self.ndown = mol.ndown
         self.nelec = self.nup + self.ndown
@@ -29,22 +27,22 @@ def get_configs(self, configs):
         if isinstance(configs, torch.Tensor):
             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)
@@ -52,10 +50,10 @@ 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)")
             raise ValueError("Config error")
 
     def sanity_check(self, nelec, norb):
@@ -68,12 +66,10 @@ def sanity_check(self, nelec, norb):
 
         """
         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
@@ -103,29 +99,21 @@ def _get_single_config(self, nocc, nvirt):
         _gs_down = list(range(self.ndown))
         cup, cdown = [_gs_up], [_gs_down]
 
-        for iocc in range(
-                self.nup - 1, self.nup - 1 - nocc[0], -1):
+        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)
+                _xt = self._create_excitation(_gs_up.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _xt, _gs_down)
+                cup, cdown = self._append_excitations(cup, cdown, _xt, _gs_down)
 
-        for iocc in range(
-                self.ndown - 1, self.ndown - 1 - nocc[1], -1):
+        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)
+                _xt = self._create_excitation(_gs_down.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _gs_up, _xt)
+                cup, cdown = self._append_excitations(cup, cdown, _gs_up, _xt)
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
@@ -143,48 +131,40 @@ 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[0], -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], -1))
-        idx_vrt_down = list(
-            range(self.ndown, self.ndown + nvirt[1], 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))
 
@@ -196,23 +176,22 @@ def _get_cas_config(self, nocc, nvirt, nelec):
             nvirt ([type]): number of virt orbitals in the CAS
         """
         from itertools import combinations, product
+
         if self.spin != 0:
             raise ValueError(
-                'CAS active space not possible with spin polarized calculation')
+                "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[0] - 1, self.nup + nvirt[0] - 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 = [], []
@@ -242,7 +221,7 @@ def _get_orb_number(self, nelec, norb):
             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])
+        nvirt = (norb - nocc[0], norb - nocc[1])
         return nocc, nvirt
 
     def _create_excitation(self, conf, iocc, ivirt):
@@ -316,7 +295,6 @@ def get_excitation(configs):
     """
     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()))
 
@@ -325,11 +303,19 @@ 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)
 
@@ -353,7 +339,6 @@ def get_unique_excitation(configs):
     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()))
 
@@ -361,11 +346,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)
@@ -374,7 +363,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)
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 5f1a3cae..a1c30ec1 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -2,7 +2,6 @@
 
 
 class OrbitalProjector:
-
     def __init__(self, configs, mol, cuda=False):
         """Project the MO matrix in Slater Matrices
 
@@ -17,9 +16,9 @@ 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')
+            self.device = torch.device("cuda")
 
     def get_projectors(self):
         """Get the projectors of the conf in the CI expansion
@@ -31,14 +30,12 @@ def get_projectors(self):
         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 ic, (cup, cdown) in enumerate(zip(self.configs[0], self.configs[1])):
             for _id, imo in enumerate(cup):
-                Pup[ic][imo, _id] = 1.
+                Pup[ic][imo, _id] = 1.0
 
             for _id, imo in enumerate(cdown):
-                Pdown[ic][imo, _id] = 1.
+                Pdown[ic][imo, _id] = 1.0
 
         return Pup.unsqueeze(1).to(self.device), Pdown.unsqueeze(1).to(self.device)
 
@@ -51,25 +48,23 @@ def split_orbitals(self, mat):
         Returns:
             torch.tensor: all slater matrices
         """
-        if not hasattr(self, 'Pup'):
+        if not hasattr(self, "Pup"):
             self.Pup, self.Pdown = self.get_projectors()
 
         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)
+            out_up = mat[..., : self.nup, :] @ self.Pup.unsqueeze(1)
+            out_down = mat[..., self.nup :, :] @ self.Pdown.unsqueeze(1)
 
         else:
             # case for single operator
-            out_up = mat[..., :self.nup, :] @ self.Pup
-            out_down = mat[..., self.nup:, :] @ self.Pdown
+            out_up = mat[..., : self.nup, :] @ self.Pup
+            out_down = mat[..., self.nup :, :] @ self.Pdown
 
         return out_up, out_down
 
 
 class ExcitationMask:
-
     def __init__(self, unique_excitations, mol, max_orb, cuda=False):
         """Select the occupied MOs of Slater determinant using masks
 
@@ -88,16 +83,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):
         """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 +100,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):
         """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 3091d04c..8ad51e01 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -32,7 +32,8 @@ 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
@@ -40,14 +41,16 @@ def __init__(self, config_method, configs, mol, cuda=False):
         self.nelec = self.nup + self.ndown
 
         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):
         """Computes the values of the determinats
@@ -58,7 +61,7 @@ def forward(self, input):
         Returns:
             torch.tensor: slater determinants
         """
-        if self.config_method.startswith('cas('):
+        if self.config_method.startswith("cas("):
             return self.det_explicit(input)
         else:
             return self.det_single_double(input)
@@ -99,12 +102,13 @@ def det_single_double(self, input):
         """
 
         # compute the determinant of the unique single excitation
-        det_unique_up, det_unique_down = self.det_unique_single_double(
-            input)
+        det_unique_up, det_unique_down = self.det_unique_single_double(input)
 
         # 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]])
+        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
@@ -113,8 +117,10 @@ def det_ground_state(self, input):
             input (torch.tensor): MO matrices nbatch x nelec x nmo
         """
 
-        return (torch.det(input[:, :self.nup, :self.nup]),
-                torch.det(input[:, self.nup:, :self.ndown]))
+        return (
+            torch.det(input[:, : self.nup, : self.nup]),
+            torch.det(input[:, self.nup :, : self.ndown]),
+        )
 
     def det_unique_single_double(self, input):
         """Computes the SD of single/double excitations
@@ -145,21 +151,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 +173,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,62 +181,57 @@ 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
 
@@ -248,18 +249,17 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
         """
 
         # 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'):
+        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("cas("):
             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:
@@ -280,18 +280,18 @@ def operator_ground_state(self, mo, bop, op_squared=False):
         """
 
         # occupied orbital matrix + det and inv on spin up
-        Aocc_up = mo[:, :self.nup, :self.nup]
+        Aocc_up = mo[:, : self.nup, : self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
+        Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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
@@ -328,7 +328,7 @@ def operator_explicit(self, mo, bkin, op_squared=False):
         Bup, Bdown = self.orb_proj.split_orbitals(bkin)
 
         # check ifwe have 1 or multiple ops
-        multiple_op = (Bup.ndim == 5)
+        multiple_op = Bup.ndim == 5
 
         # inverse of MO matrices
         iAup = torch.inverse(Aup)
@@ -373,11 +373,12 @@ def operator_single_double(self, mo, bop, op_squared=False):
             torch.tensor: kinetic energy values
         """
 
-        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)
 
-        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):
         """Compute the operator value of the unique single/double conformation
@@ -390,33 +391,33 @@ def operator_unique_single_double(self, mo, bop, op_squared):
 
         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]
+        Aocc_up = mo[:, : self.nup, : self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
+        Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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,73 +430,85 @@ 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_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_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:
-
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             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
         # typically trace(ABAB)
         else:
-
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -509,42 +522,56 @@ 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
 
@@ -566,7 +593,7 @@ def op_single(baseterm, mat_exc, M, index, nbatch):
         """
 
         # 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]
@@ -635,14 +662,14 @@ def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
         """
 
         # 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
@@ -691,7 +718,7 @@ 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
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 358221f5..33fde499 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,5 +1,3 @@
-
-
 import torch
 from scipy.optimize import curve_fit
 from copy import deepcopy
@@ -19,14 +17,16 @@
 
 
 class SlaterJastrow(WaveFunction):
-
-    def __init__(self, mol,
-                 jastrow=None,
-                 backflow=None,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        jastrow=None,
+        backflow=None,
+        configs="ground_state",
+        kinetic="jacobi",
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
         .. math::
@@ -37,19 +37,19 @@ def __init__(self, mol,
         .. 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_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels        
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation    
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
             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
             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
@@ -61,16 +61,15 @@ def __init__(self, mol,
             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
 
-        super().__init__(mol.nelec, 3,  kinetic, cuda)
+        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')
+            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')
+        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
@@ -102,10 +101,7 @@ def __init__(self, mol,
         self.init_kinetic(kinetic, backflow)
 
         # register the callable for hdf5 dump
-        register_extra_attributes(self,
-                                  ['ao', 'mo_scf',
-                                   'mo', 'jastrow',
-                                   'pool', 'fc'])
+        register_extra_attributes(self, ["ao", "mo_scf", "mo", "jastrow", "pool", "fc"])
 
         self.log_data()
 
@@ -115,8 +111,7 @@ def init_atomic_orb(self, backflow):
         if self.backflow is None:
             self.ao = AtomicOrbitals(self.mol, self.cuda)
         else:
-            self.ao = AtomicOrbitalsBackFlow(
-                self.mol, self.backflow, self.cuda)
+            self.ao = AtomicOrbitalsBackFlow(self.mol, self.backflow, self.cuda)
 
         if self.cuda:
             self.ao = self.ao.to(self.device)
@@ -129,8 +124,7 @@ def init_molecular_orb(self, include_all_mo):
         self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
 
         # scf layer
-        self.mo_scf = nn.Linear(
-            self.mol.basis.nao, self.nmo_opt, bias=False)
+        self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
         self.mo_scf.weight = self.get_mo_coeffs()
         self.mo_scf.weight.requires_grad = False
 
@@ -145,8 +139,7 @@ def init_mo_mixer(self):
         self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
 
         # init the weight to idenity matrix
-        self.mo.weight = nn.Parameter(
-            torch.eye(self.nmo_opt, self.nmo_opt))
+        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
 
         # put on the card if needed
         if self.cuda:
@@ -160,15 +153,15 @@ def init_config(self, configs):
         self.configs_method = configs
         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
+        self.highest_occ_mo = max(self.configs[0].max(), self.configs[1].max()) + 1
 
     def init_slater_det_calculator(self):
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method,
-                                  self.configs, self.mol, self.cuda)
+        self.pool = SlaterPooling(
+            self.configs_method, self.configs, self.mol, self.cuda
+        )
 
     def init_fc_layer(self):
         """Init the fc layer"""
@@ -177,8 +170,8 @@ def init_fc_layer(self):
         self.fc = nn.Linear(self.nci, 1, bias=False)
 
         # set all weight to 0 except the groud state
-        self.fc.weight.data.fill_(0.)
-        self.fc.weight.data[0][0] = 1.
+        self.fc.weight.data.fill_(0.0)
+        self.fc.weight.data[0][0] = 1.0
 
         # port to card
         if self.cuda:
@@ -208,10 +201,10 @@ def set_combined_jastrow(self, jastrow):
         self.jastrow = CombineJastrow(jastrow)
 
     def init_kinetic(self, kinetic, backflow):
-        """"Init the calculator of the kinetic energies"""
+        """ "Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
-        if kinetic == 'jacobi':
+        if kinetic == "jacobi":
             if backflow is None:
                 self.kinetic_energy = self.kinetic_energy_jacobi
 
@@ -392,7 +385,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
@@ -405,11 +397,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
@@ -420,7 +411,7 @@ 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, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -434,10 +425,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
@@ -451,7 +439,7 @@ def get_kinetic_operator(self, x, ao, dao, d2ao,  mo):
 
         return -0.5 * bkin
 
-    def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
+    def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -485,8 +473,7 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -507,10 +494,12 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
         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 = (
+            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
 
@@ -518,9 +507,7 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -537,15 +524,13 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -556,42 +541,37 @@ def gradients_jacobi_backflow(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
 
     def log_data(self):
         """Print information abut the wave function."""
-        log.info('')
-        log.info(' Wave Function')
-        log.info('  Jastrow factor      : {0}', self.use_jastrow)
+        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.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      : ')
+        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()])
+            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)
+        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))
+            log.info("  GPU                 : {0}", torch.cuda.get_device_name(0))
 
     def get_mo_coeffs(self):
         """Get the molecular orbital coefficients to init the mo layer."""
-        mo_coeff = torch.as_tensor(self.mol.basis.mos).type(
-            torch.get_default_dtype())
+        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]
+            mo_coeff = mo_coeff[:, : self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -610,20 +590,19 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-            xyz = self.ao.atom_coords[iat,
-                                      :].cpu().detach().numpy().tolist()
+            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
+        The SZ sto that have only one basis function per ao
         """
 
-        assert(self.ao.radial_type.startswith('gto'))
-        assert(self.ao.harmonics_type == 'cart')
+        assert self.ao.radial_type.startswith("gto")
+        assert self.ao.harmonics_type == "cart"
 
-        log.info('  Fit GTOs to STOs  : ')
+        log.info("  Fit GTOs to STOs  : ")
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -637,7 +616,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = 'sto_pure'
+        basis.radial_type = "sto_pure"
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -655,14 +634,12 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -673,16 +650,20 @@ def sto(x, norm, alpha):
             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()
+            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:
                 import matplotlib.pyplot as plt
+
                 plt.plot(xdata, ydata)
                 plt.plot(xdata, sto(xdata, *popt))
                 plt.show()
@@ -691,8 +672,12 @@ def sto(x, norm, alpha):
         new_mol.basis = basis
 
         # returns new orbital instance
-        return self.__class__(new_mol, self.jastrow, backflow=self.backflow,
-                              configs=self.configs_method,
-                              kinetic=self.kinetic_method,
-                              cuda=self.cuda,
-                              include_all_mo=self.include_all_mo)
+        return self.__class__(
+            new_mol,
+            self.jastrow,
+            backflow=self.backflow,
+            configs=self.configs_method,
+            kinetic=self.kinetic_method,
+            cuda=self.cuda,
+            include_all_mo=self.include_all_mo,
+        )
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 15cec289..e1b5e2d4 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -3,18 +3,22 @@
 
 from .slater_jastrow import SlaterJastrow
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        jastrow_kernel=PadeJastrowKernel,
+        jastrow_kernel_kwargs={},
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Slater Jastrow Wave function with an orbital dependent Electron-Electron Jastrow Factor
 
         .. math::
@@ -23,17 +27,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,7 +53,8 @@ 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, None, None, configs, kinetic, cuda, include_all_mo)
         self.use_jastrow = True
@@ -60,7 +65,8 @@ def __init__(self, mol,
             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)
@@ -176,21 +182,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])
 
@@ -200,10 +206,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)
@@ -212,7 +217,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, **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
@@ -247,10 +252,12 @@ 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)
@@ -264,7 +271,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)
@@ -303,8 +311,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
@@ -334,12 +341,12 @@ 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):
         """Compute the gradient operator
@@ -370,7 +377,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/trash/slater_combined_jastrow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
index b308d190..b468f129 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
@@ -1,28 +1,31 @@
-
-
 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.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 .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):
+    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::
@@ -31,7 +34,7 @@ def __init__(self, mol, configs='ground_state',
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+            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
 
@@ -39,13 +42,13 @@ def __init__(self, mol, configs='ground_state',
             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 (dict, optional) : different Jastrow kernels for the different terms. 
+            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.
@@ -62,22 +65,23 @@ def __init__(self, mol, configs='ground_state',
 
         # process the Jastrow
         if jastrow_kernel is not None:
-
-            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():
                     jastrow_kernel_kwargs[k] = None
 
             self.use_jastrow = True
-            self.jastrow_type = 'JastrowFactorCombinedTerms'
+            self.jastrow_type = "JastrowFactorCombinedTerms"
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
+                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)
+                cuda=cuda,
+            )
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
diff --git a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
index 023ea286..e411e7c5 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
@@ -1,38 +1,43 @@
-
-
 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.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 .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.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):
+    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::
@@ -41,7 +46,7 @@ def __init__(self, mol, configs='ground_state',
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+            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
 
@@ -56,23 +61,23 @@ def __init__(self, mol, configs='ground_state',
             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 (dict, optional) : different Jastrow kernels for the different terms. 
+            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. 
+            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 
+            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
@@ -85,32 +90,35 @@ def __init__(self, mol, configs='ground_state',
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda
+            )
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                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']:
+            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_type = "JastrowFactorCombinedTerms"
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
+                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)
+                cuda=cuda,
+            )
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
@@ -183,7 +191,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    def kinetic_energy_jacobi(self, x, **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -217,8 +225,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -239,10 +246,12 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         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 = (
+            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
 
@@ -250,9 +259,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -269,15 +276,13 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -288,4 +293,5 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
diff --git a/qmctorch/wavefunction/trash/slater_jastrow.py b/qmctorch/wavefunction/trash/slater_jastrow.py
index 81b84492..3cbae13c 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow.py
@@ -1,21 +1,24 @@
-
-
 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 .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 
 class SlaterJastrow(SlaterJastrowBase):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        jastrow_kernel=PadeJastrowKernel,
+        jastrow_kernel_kwargs={},
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Implementation of the QMC Network.
 
         Args:
@@ -36,12 +39,15 @@ def __init__(self, mol, configs='ground_state',
 
         # process the Jastrow
         if jastrow_kernel is not None:
-
             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)
+                self.mol.nup,
+                self.mol.ndown,
+                jastrow_kernel,
+                kernel_kwargs=jastrow_kernel_kwargs,
+                cuda=cuda,
+            )
 
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
@@ -213,7 +219,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
@@ -226,11 +231,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
@@ -241,7 +245,7 @@ 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, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -255,10 +259,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
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
index 38690d0a..da7b6cdb 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
@@ -1,5 +1,3 @@
-
-
 import torch
 
 from torch import nn
@@ -8,24 +6,31 @@
 from .. import log
 
 from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from .orbitals.atomic_orbitals_orbital_dependent_backflow import AtomicOrbitalsOrbitalDependentBackFlow
+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
+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):
+    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::
@@ -35,7 +40,7 @@ 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, and
 
         .. math::
@@ -49,22 +54,22 @@ def __init__(self, mol, configs='ground_state',
             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
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation. 
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation.
                 - By default an inverse kernel K(r_{ij}) = w/r_{ij} is used
             backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
-            orbital_dependent_backflow (bool, optional) : every orbital has a different transformation if True. Default to False 
+            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
@@ -77,15 +82,21 @@ def __init__(self, mol, configs='ground_state',
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda
+            )
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                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)
+            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
@@ -162,7 +173,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    def kinetic_energy_jacobi(self, x, **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -196,8 +207,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -218,10 +228,12 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         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 = (
+            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
 
@@ -229,9 +241,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -248,15 +258,13 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -267,4 +275,5 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_base.py b/qmctorch/wavefunction/trash/slater_jastrow_base.py
index 3214b488..24a545eb 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_base.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_base.py
@@ -16,40 +16,40 @@
 
 
 class SlaterJastrowBase(WaveFunction):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
+    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(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
             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)
+        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')
+            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')
+        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
@@ -61,7 +61,7 @@ def __init__(self, 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
+        self.highest_occ_mo = torch.stack(self.configs).max() + 1
 
         # define the atomic orbital layer
         self.ao = AtomicOrbitals(mol, cuda)
@@ -69,8 +69,7 @@ def __init__(self, mol,
         # 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 = 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:
@@ -79,8 +78,7 @@ def __init__(self, mol,
         # 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))
+        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
         if self.cuda:
             self.mo.to(self.device)
 
@@ -89,69 +87,59 @@ def __init__(self, mol,
         self.use_jastrow = False
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method,
-                                  self.configs, mol, cuda)
+        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.
+        self.fc.weight.data.fill_(0.0)
+        self.fc.weight.data[0][0] = 1.0
 
         if self.cuda:
             self.fc = self.fc.to(self.device)
 
         self.kinetic_method = kinetic
-        if kinetic == 'jacobi':
+        if kinetic == "jacobi":
             self.kinetic_energy = self.kinetic_energy_jacobi
 
-        gradients = 'auto'
+        gradients = "auto"
         self.gradients_method = gradients
-        if gradients == 'jacobi':
+        if gradients == "jacobi":
             self.gradients = self.gradients_jacobi
 
         if self.cuda:
-            self.device = torch.device('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'])
+        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)
+        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.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      : ')
+        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()])
+            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)
+        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))
+            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())
+        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]
+            mo_coeff = mo_coeff[:, : self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -169,21 +157,19 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-
-            xyz = self.ao.atom_coords[iat,
-                                      :].cpu().detach().numpy().tolist()
+            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
+        The SZ sto that have only one basis function per ao
         """
 
-        assert(self.ao.radial_type.startswith('gto'))
-        assert(self.ao.harmonics_type == 'cart')
+        assert self.ao.radial_type.startswith("gto")
+        assert self.ao.harmonics_type == "cart"
 
-        log.info('  Fit GTOs to STOs  : ')
+        log.info("  Fit GTOs to STOs  : ")
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -197,7 +183,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = 'sto_pure'
+        basis.radial_type = "sto_pure"
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -215,14 +201,12 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -233,12 +217,15 @@ def sto(x, norm, alpha):
             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()
+            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:
@@ -250,10 +237,13 @@ def sto(x, norm, alpha):
         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)
+        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
@@ -275,11 +265,11 @@ def forward(self, x, ao=None):
             >>> vals = wf(pos)
         """
 
-        raise NotImplementedError('Implement a forward method')
+        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')
+        raise NotImplementedError("Implement a ao2mo method")
 
     def pos2mo(self, x, derivative=0):
         """Get the values of MOs from the positions
@@ -293,9 +283,9 @@ def pos2mo(self, x, derivative=0):
         Returns:
             torch.tensor -- MO matrix [nbatch, nelec, nmo]
         """
-        raise NotImplementedError('Implement a get_mo_vals method')
+        raise NotImplementedError("Implement a get_mo_vals method")
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    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 .
 
@@ -309,8 +299,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             torch.tensor: values of the kinetic energy at each sampling points
         """
 
-        raise NotImplementedError(
-            'Implement a kinetic_energy_jacobi method')
+        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
@@ -327,8 +316,7 @@ def gradients_jacobi(self, x, pdf=False):
             torch.tensor: values of the gradients wrt the walker pos at each sampling points
         """
 
-        raise NotImplementedError(
-            'Implement a gradient_jacobi method')
+        raise NotImplementedError("Implement a gradient_jacobi method")
 
     def get_gradient_operator(self, x, ao, grad_ao, mo):
         """Compute the gradient operator
@@ -339,10 +327,9 @@ def get_gradient_operator(self, x, ao, grad_ao, mo):
             dao ([type]): [description]
         """
 
-        raise NotImplementedError(
-            'Implement a get_grad_operator method')
+        raise NotImplementedError("Implement a get_grad_operator method")
 
-    def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
+    def get_hessian_operator(self, x, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -353,5 +340,4 @@ def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
             torch.tensor: matrix of the kinetic operator
         """
 
-        raise NotImplementedError(
-            'Implement a get_kinetic_operator method')
+        raise NotImplementedError("Implement a get_kinetic_operator method")
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_graph.py b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
index 2d5c7a19..727fce01 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_graph.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
@@ -1,27 +1,30 @@
-
-
 import numpy as np
 import torch
 from .slater_jastrow import SlaterJastrow
 
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 from .jastrows.graph.jastrow_graph import JastrowFactorGraph
 from .jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
 
 
 class SlaterJastrowGraph(SlaterJastrow):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 ee_model=MGCNPredictor,
-                 ee_model_kwargs={},
-                 en_model=MGCNPredictor,
-                 en_model_kwargs={},
-                 atomic_features=["atomic_number"],
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Implementation of a SlaterJastrow Network using Graph neural network to express the Jastrow.
 
         Args:
@@ -43,19 +46,23 @@ def __init__(self, mol, configs='ground_state',
 
         super().__init__(mol, configs, kinetic, None, None, cuda, include_all_mo)
 
-        self.jastrow_type = 'Graph(ee:%s, en:%s)' % (
-            ee_model.__name__, en_model.__name__)
+        self.jastrow_type = "Graph(ee:%s, en:%s)" % (
+            ee_model.__name__,
+            en_model.__name__,
+        )
         self.use_jastrow = True
-        self.jastrow = JastrowFactorGraph(mol.nup, mol.ndown,
-                                          torch.as_tensor(
-                                              mol.atom_coords),
-                                          mol.atoms,
-                                          ee_model=ee_model,
-                                          ee_model_kwargs=ee_model_kwargs,
-                                          en_model=en_model,
-                                          en_model_kwargs=en_model_kwargs,
-                                          atomic_features=atomic_features,
-                                          cuda=cuda)
+        self.jastrow = JastrowFactorGraph(
+            mol.nup,
+            mol.ndown,
+            torch.as_tensor(mol.atom_coords),
+            mol.atoms,
+            ee_model=ee_model,
+            ee_model_kwargs=ee_model_kwargs,
+            en_model=en_model,
+            en_model_kwargs=en_model_kwargs,
+            atomic_features=atomic_features,
+            cuda=cuda,
+        )
 
         if self.cuda:
             self.jastrow = self.jastrow.to(self.device)
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index 85fb5e55..e0067a71 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -4,9 +4,7 @@
 
 
 class WaveFunction(torch.nn.Module):
-
-    def __init__(self, nelec, ndim, kinetic='auto', cuda=False):
-
+    def __init__(self, nelec, ndim, kinetic="auto", cuda=False):
         super(WaveFunction, self).__init__()
 
         self.ndim = ndim
@@ -14,14 +12,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.
+        """Compute the value of the wave function.
         for a multiple conformation of the electrons
 
         Args:
@@ -29,7 +27,7 @@ def forward(self, x):
             pos: position of the electrons
 
         Returns: values of psi
-        '''
+        """
 
         raise NotImplementedError()
 
@@ -49,13 +47,11 @@ 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):
@@ -79,7 +75,7 @@ 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)
 
@@ -93,14 +89,14 @@ 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
 
@@ -118,13 +114,11 @@ 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
 
@@ -143,21 +137,16 @@ 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]
 
@@ -166,64 +155,66 @@ def kinetic_energy_autograd(self, pos):
     def local_energy(self, pos):
         """Computes the local energy
 
-         .. math::
-             E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
-
-         Args:
-             pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
+        .. math::
+            E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
 
-         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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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):
         """Computes the total number of parameters."""
@@ -233,7 +224,7 @@ def get_number_parameters(self):
                 nparam += param.data.numel()
         return nparam
 
-    def load(self, filename, group='wf_opt', model='best'):
+    def load(self, filename, group="wf_opt", model="best"):
         """Load trained parameters
 
         Args:
@@ -242,8 +233,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 20159170..6f8f9bf1 100644
--- a/setup.py
+++ b/setup.py
@@ -2,54 +2,64 @@
 
 import os
 
-from setuptools import (find_packages, setup)
+from setuptools import find_packages, setup
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 # To update the package version number, edit QMCTorch/__version__.py
 version = {}
-with open(os.path.join(here, 'qmctorch', '__version__.py')) as f:
+with open(os.path.join(here, "qmctorch", "__version__.py")) as f:
     exec(f.read(), version)
 
-with open('README.md') as readme_file:
+with open("README.md") as readme_file:
     readme = readme_file.read()
 
 setup(
-    name='qmctorch',
-    version=version['__version__'],
+    name="qmctorch",
+    version=version["__version__"],
     description="Pytorch Implementation of Quantum Monte Carlo",
-    long_description=readme + '\n\n',
-    long_description_content_type='text/markdown',
+    long_description=readme + "\n\n",
+    long_description_content_type="text/markdown",
     author=["Nicolas Renaud", "Felipe Zapata"],
-    author_email='n.renaud@esciencecenter.nl',
-    url='https://github.com/NLESC-JCER/QMCTorch',
+    author_email="n.renaud@esciencecenter.nl",
+    url="https://github.com/NLESC-JCER/QMCTorch",
     packages=find_packages(),
-    package_dir={'qmctorch': 'qmctorch'},
+    package_dir={"qmctorch": "qmctorch"},
     include_package_data=True,
     license="Apache Software License 2.0",
     zip_safe=False,
-    keywords='qmctorch',
-    scripts=['bin/qmctorch'],
+    keywords="qmctorch",
+    scripts=["bin/qmctorch"],
     classifiers=[
-        'Development Status :: 4 - Beta',
-        'Intended Audience :: Science/Research',
-        'License :: OSI Approved :: Apache Software License',
-        'Natural Language :: English',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.8',
-        'Topic :: Scientific/Engineering :: Chemistry'
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: Apache Software License",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Topic :: Scientific/Engineering :: Chemistry",
+    ],
+    test_suite="tests",
+    install_requires=[
+        "matplotlib",
+        "numpy",
+        "argparse",
+        "scipy",
+        "tqdm",
+        "torch",
+        "dgl",
+        "dgllife",
+        "plams",
+        "pints",
+        "pyscf",
+        "mendeleev",
+        "twiggy",
+        "plams",
+        "mpi4py",
     ],
-    test_suite='tests',
-    install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
-                      'plams', 'pints',
-                      'pyscf', 'mendeleev', 'twiggy',
-                      'plams', 'mpi4py'],
-
     extras_require={
-        'hpc': ['horovod==0.27.0'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx'],
-        'test': ['pytest', 'pytest-runner',
-                 'coverage', 'coveralls', 'pycodestyle'],
-    }
+        "hpc": ["horovod==0.27.0"],
+        "doc": ["recommonmark", "sphinx", "sphinx_rtd_theme", "nbsphinx"],
+        "test": ["pytest", "pytest-runner", "coverage", "coveralls", "pycodestyle"],
+    },
 )
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..0545b468 100644
--- a/tests/sampler/test_generalized_metropolis.py
+++ b/tests/sampler/test_generalized_metropolis.py
@@ -5,13 +5,16 @@
 
 
 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)
 
diff --git a/tests/sampler/test_hamiltonian.py b/tests/sampler/test_hamiltonian.py
index 88b866a3..8ffb7c8d 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,7 +13,8 @@ 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)
 
diff --git a/tests/sampler/test_metropolis.py b/tests/sampler/test_metropolis.py
index 49ccf446..7bf41d3d 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,12 +15,12 @@ def test_metropolis(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
-
-        for m in ['one-elec', 'all-elec', 'all-elec-iter']:
-            for p in ['normal', 'uniform']:
+            init=self.mol.domain("normal"),
+        )
 
-                sampler.configure_move({'type': m, 'proba': p})
+        for m in ["one-elec", "all-elec", "all-elec-iter"]:
+            for p in ["normal", "uniform"]:
+                sampler.configure_move({"type": m, "proba": p})
                 pos = sampler(self.wf.pdf)
 
     def test_metropolis_logspace(self):
@@ -33,13 +32,13 @@ def test_metropolis_logspace(self):
             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']:
+            init=self.mol.domain("normal"),
+            logspace=True,
+        )
 
-                sampler.configure_move({'type': m, 'proba': p})
+        for m in ["one-elec", "all-elec", "all-elec-iter"]:
+            for p in ["normal", "uniform"]:
+                sampler.configure_move({"type": m, "proba": p})
                 pos = sampler(self.wf.pdf)
 
 
diff --git a/tests/sampler/test_metropolis_hasting.py b/tests/sampler/test_metropolis_hasting.py
index f8a1c007..e9a2206d 100644
--- a/tests/sampler/test_metropolis_hasting.py
+++ b/tests/sampler/test_metropolis_hasting.py
@@ -1,11 +1,13 @@
 import unittest
 from qmctorch.sampler import MetropolisHasting
-from qmctorch.sampler.proposal_kernels import ConstantVarianceKernel, CenterVarianceKernel
+from qmctorch.sampler.proposal_kernels import (
+    ConstantVarianceKernel,
+    CenterVarianceKernel,
+)
 from .test_sampler_base import TestSamplerBase
 
 
 class TestMetropolisHasting(TestSamplerBase):
-
     def test_ConstantKernel(self):
         """Test Metropolis sampling."""
 
@@ -14,8 +16,9 @@ def test_ConstantKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            kernel=ConstantVarianceKernel())
+            init=self.mol.domain("normal"),
+            kernel=ConstantVarianceKernel(),
+        )
 
         _ = sampler(self.wf.pdf)
 
@@ -27,8 +30,9 @@ def test_CenterVarianceKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            kernel=CenterVarianceKernel())
+            init=self.mol.domain("normal"),
+            kernel=CenterVarianceKernel(),
+        )
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_pints.py b/tests/sampler/test_pints.py
index a4c2674e..6bb11e35 100644
--- a/tests/sampler/test_pints.py
+++ b/tests/sampler/test_pints.py
@@ -7,7 +7,6 @@
 
 
 class TestPints(TestSamplerBase):
-
     def test_Haario(self):
         """Test Metropolis sampling."""
 
@@ -16,8 +15,9 @@ def test_Haario(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            method=pints.HaarioBardenetACMC)
+            init=self.mol.domain("normal"),
+            method=pints.HaarioBardenetACMC,
+        )
 
         _ = sampler(self.wf.pdf)
 
@@ -29,9 +29,10 @@ def test_Langevin(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
+            init=self.mol.domain("normal"),
             method=pints.MALAMCMC,
-            method_requires_grad=True)
+            method_requires_grad=True,
+        )
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index b29547b1..37862707 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestSamplerBase(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,13 +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)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # orbital
         self.wf = SlaterJastrow(self.mol, jastrow=jastrow)
diff --git a/tests/sampler/test_walker.py b/tests/sampler/test_walker.py
index 3554311b..67131c6f 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'))
+        w1 = 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'))
+        w2 = 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'))
+        w3 = 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'))
+        w4 = 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 31f39f4d..9392faa0 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestGTO2STOFit(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,36 +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,
+        )
 
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol, kinetic='auto',
-                                configs='ground_state', jastrow=jastrow).gto2sto()
+        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 = -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..2c68e38b 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')
+        mol = 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
index 594eb2f6..13a0565a 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -6,9 +6,7 @@
 
 
 class BaseTestSolvers:
-
     class BaseTestSolverMolecule(unittest.TestCase):
-
         def setUp(self):
             self.mol = None
             self.wf = None
@@ -20,7 +18,6 @@ def setUp(self):
             self.expected_variance = None
 
         def test1_single_point(self):
-
             # sample and compute observables
             obs = self.solver.single_point()
             e, v = obs.energy, obs.variance
@@ -34,13 +31,13 @@ def test1_single_point(self):
             #         np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
 
         def test2_wf_opt_grad_auto(self):
-
-            self.solver.configure(track=['local_energy', 'parameters'],
-                                  loss='energy', grad='auto')
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="auto"
+            )
             _ = self.solver.run(5)
 
         def test3_wf_opt_grad_manual(self):
-
-            self.solver.configure(track=['local_energy', 'parameters'],
-                                  loss='energy', grad='manual')
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="manual"
+            )
             _ = self.solver.run(5)
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index aabaf28e..1fccd751 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -19,23 +19,20 @@
 
 
 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)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -44,24 +41,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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1572532653808594,
-                                -1.1501641653648578]
+        self.expected_energy = [-1.1572532653808594, -1.1501641653648578]
 
-        self.expected_variance = [0.05085879936814308,
-                                  0.05094174843043177]
+        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 950a7686..61143675 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -14,21 +14,19 @@
 
 
 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)', jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -37,24 +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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1571345329284668,
-                                -1.1501641653648578]
+        self.expected_energy = [-1.1571345329284668, -1.1501641653648578]
 
-        self.expected_variance = [0.05087674409151077,
-                                  0.05094174843043177]
+        self.expected_variance = [0.05087674409151077, 0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index ff62759e..b61e8e50 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -6,10 +6,13 @@
 
 
 from qmctorch.sampler import Metropolis
-from qmctorch.utils.plot_data 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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
@@ -19,9 +22,7 @@
 
 
 class TestH2GeoOpt(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -31,19 +32,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -52,31 +53,25 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
     def test_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.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.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.load(self.solver.hdf5file, "geo_opt")
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -88,8 +83,8 @@ def test_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert(e > 2 * gse and e < 0.)
-        assert(v > 0 and v < 2.)
+        assert e > 2 * gse and e < 0.0
+        assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index d02680d3..3c20711f 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -17,9 +17,7 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -29,18 +27,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -48,22 +47,20 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        self.expected_energy = [-1.0877732038497925, -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        self.expected_variance = [0.14341972768306732, 0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 6951f435..f7702dc8 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -17,9 +17,7 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -29,18 +27,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)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -48,22 +47,20 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        self.expected_energy = [-1.0877732038497925, -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        self.expected_variance = [0.14341972768306732, 0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 15bc1f28..895dca4a 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -18,9 +18,7 @@
 
 
 class TestH2SamplerMH(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -30,19 +28,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -51,39 +49,31 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.1464850902557373,
-                                -1.14937478612449]
+        self.expected_energy = [-1.1464850902557373, -1.14937478612449]
 
         # values on different arch
-        self.expected_variance = [0.9279592633247375,
-                                  0.7445300449383236]
+        self.expected_variance = [0.9279592633247375, 0.7445300449383236]
 
     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.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.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.load(self.solver.hdf5file, "geo_opt")
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -95,8 +85,8 @@ def test4_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert(e > 2 * gse and e < 0.)
-        assert(v > 0 and v < 2.)
+        assert e > 2 * gse and e < 0.0
+        assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index 76f77ddd..1cecf465 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,19 +6,20 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
-from qmctorch.utils.plot_data 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.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)
 
@@ -28,17 +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)', jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -49,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)
 
@@ -70,7 +70,6 @@ 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)
 
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index ec91a8ff..606ed2b4 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -8,7 +8,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -17,16 +20,13 @@
 
 
 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
@@ -34,21 +34,26 @@ def setUp(self):
 
         # backflow
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=False)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -57,22 +62,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index 5ceceafc..c64b46a7 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,8 +78,7 @@ 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')
+        self.solver.configure(track=["local_energy"], loss="energy", grad="manual")
         obs = self.solver.run(5)
 
 
diff --git a/tests/solver/test_lih_pyscf.py b/tests/solver/test_lih_pyscf.py
index e287934c..20be58b7 100644
--- a/tests/solver/test_lih_pyscf.py
+++ b/tests/solver/test_lih_pyscf.py
@@ -14,26 +14,29 @@
 
 
 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')
+            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)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -42,17 +45,15 @@ 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)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 1d6cc922..8fc7c199 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -9,7 +9,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -17,40 +20,44 @@
 
 
 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -59,22 +66,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index dec3033a..fdcff7ba 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -10,7 +10,10 @@
 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
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.utils import set_torch_double_precision
 
 
@@ -20,49 +23,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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # backflow wave function
-        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.
+        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, jastrow=jastrow_ref, backflow=None,
-                                    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)
@@ -71,10 +83,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
@@ -84,10 +99,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(
@@ -96,10 +110,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()
@@ -109,20 +122,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)
@@ -132,11 +143,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()
@@ -154,58 +163,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 d8486308..0b5156be 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -9,7 +9,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelPowerSum
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelPowerSum,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -17,40 +20,44 @@
 
 
 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)
+            self.mol, BackFlowKernelPowerSum, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -59,22 +66,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
index c76ba7ce..c43e3564 100644
--- a/tests/solver/test_lih_pyscf_generic_jastrow.py
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -8,35 +8,40 @@
 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.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')
+            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)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -45,22 +50,19 @@ 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 test2_wf_opt_grad_auto(self):
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 118d994d..a4202d89 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -9,7 +9,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -17,40 +20,44 @@
 
 
 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -59,22 +66,19 @@ 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
 
 
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 6a74199f..b8229b52 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -2,60 +2,54 @@
 
 import torch
 
-from qmctorch.utils import (InterpolateAtomicOrbitals,
-                            InterpolateMolecularOrbitals)
+from qmctorch.utils import InterpolateAtomicOrbitals, InterpolateMolecularOrbitals
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 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)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)', jastrow=jastrow)
+        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')
+        inter = interp_mo(self.pos, method="reg")
         ref = self.wf.mo(self.wf.mo_scf(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')
+        inter = interp_mo(self.pos, method="irreg")
         ref = self.wf.mo(self.wf.mo_scf(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
index bfa699bb..9a1a940f 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -8,21 +8,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]
 
@@ -30,9 +25,7 @@ def hess(out, pos):
 
 
 class BaseTestCases:
-
     class WaveFunctionBaseTest(unittest.TestCase):
-
         def setUp(self):
             """Init the base test"""
             self.pos = None
@@ -50,8 +43,10 @@ def test_antisymmetry(self):
 
             if self.wf.nelec < 4:
                 print(
-                    'Warning : antisymmetry cannot be tested with \
-                        only %d electrons' % self.wf.nelec)
+                    "Warning : antisymmetry cannot be tested with \
+                        only %d electrons"
+                    % self.wf.nelec
+                )
                 return
 
             # test spin up
@@ -60,23 +55,21 @@ def test_antisymmetry(self):
             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)
+            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))
+            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
+            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)
+            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))
+            assert torch.allclose(wfvals_ref, -1 * wfvals_xdn)
 
         def test_grad_mo(self):
             """Gradients of the MOs."""
@@ -84,16 +77,14 @@ def test_grad_mo(self):
             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]
+            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)))
+            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."""
@@ -102,71 +93,62 @@ def test_hess_mo(self):
             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(), 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).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)))
+            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)
+            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)
+            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()
+            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))
+            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)
+            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()))
+            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 = 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))
+            assert torch.allclose(psum_mo, psum_mo_grad)
 
         def test_grad_mo(self):
             """Gradients of the BF MOs."""
@@ -176,15 +158,13 @@ def test_grad_mo(self):
             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_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))
+            assert torch.allclose(dmo, dmo_grad)
 
         def test_hess_mo(self):
             """Hessian of the MOs."""
@@ -194,14 +174,12 @@ def test_hess_mo(self):
             d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
             d2val = self.wf.ao2mo(d2ao)
 
-            assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+            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 = 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))
+            assert torch.allclose(d2val, d2val_grad)
 
         def test_gradients_wf(self):
             pass
diff --git a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
index f0560f72..b843c7a4 100644
--- a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
+++ b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
@@ -9,21 +9,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]
 
@@ -31,7 +26,6 @@ def hess(out, pos):
 
 
 class TestElecElecDistance(unittest.TestCase):
-
     def setUp(self):
         self.nup, self.ndown = 1, 1
         self.nelec = self.nup + self.ndown
@@ -72,15 +66,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/base_elec_elec_jastrow_test.py b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
index 745bb179..9f5b5ed5 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -8,21 +8,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]
 
@@ -30,9 +25,7 @@ def hess(out, pos):
 
 
 class BaseTestJastrow:
-
     class ElecElecJastrowBaseTest(unittest.TestCase):
-
         def setUp(self) -> None:
             """Init the test case"""
             self.jastrow = None
@@ -44,7 +37,6 @@ def test_jastrow(self):
             val = self.jastrow(self.pos)
 
         def test_permutation(self):
-
             jval = self.jastrow(self.pos)
 
             # test spin up
@@ -53,64 +45,48 @@ def test_permutation(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)
 
             jval_xup = self.jastrow(pos_xup)
-            assert(torch.allclose(jval, jval_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]
+            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_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 = 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_grad_jastrow(self):
-
             val = self.jastrow(self.pos)
-            dval = self.jastrow(
-                self.pos, derivative=1, sum_grad=False)
+            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 = 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, dval_grad.transpose(1, 2))
-            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, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2)
+            )
 
-            assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+            assert torch.allclose(d2val.sum(), d2val_grad.sum())
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index ef8fa1cc..dc9d78a3 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -7,28 +6,28 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.fully_connected_jastrow_kernel import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestGenericJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         mol = SimpleNamespace(nup=4, ndown=4)
         self.nelec = mol.nup + mol.ndown
 
-        self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            FullyConnectedJastrowKernel)
+        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
 
 
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 7bb0a1da..4f6fd241 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -5,16 +5,18 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -22,9 +24,8 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            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)
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 13a33a17..43dc6135 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -8,16 +7,18 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import (
+    PadeJastrowPolynomialKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -25,10 +26,14 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, 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)
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 4d7bdbcf..9dca1be1 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -5,16 +5,18 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -22,10 +24,8 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            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)
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 626d7535..d6f29843 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,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -8,16 +7,18 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import (
+    PadeJastrowPolynomialKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -25,11 +26,15 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowPolynomialKernel,
-            kernel_kwargs={'order': 5,
-                           'weight_a': 0.1*torch.ones(5),
-                           'weight_b': 0.1*torch.ones(5)},
-            scale=True)
+            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)
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 5d116766..3e27287e 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
@@ -15,19 +15,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 d7c3f2c1..4ca2034a 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
+    BoysHandyJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,55 +33,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*np.random.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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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
@@ -91,54 +81,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 1227ba48..3abeddc5 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,92 +33,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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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/test_electron_nuclei_fully_connected.py b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
index f019dcbc..1d793868 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
@@ -3,8 +3,12 @@
 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 import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
+    JastrowFactorElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,9 +33,7 @@ def hess(out, pos):
 
 
 class TestElectronNucleiGeneric(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -44,50 +41,41 @@ def setUp(self):
         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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronNuclei(
-            self.mol, 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 832beb5d..e9f995b2 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
@@ -4,8 +4,12 @@
 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.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
+    JastrowFactorElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -13,21 +17,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,9 +34,7 @@ def hess(out, pos):
 
 
 class TestElectronNucleiPadeJastrow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -45,51 +42,40 @@ def setUp(self):
         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.mol, PadeJastrowKernel)
+            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/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index a9bb3d1b..67ac08ab 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -12,21 +12,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]
 
@@ -34,9 +29,7 @@ def hess(out, pos):
 
 
 class TestGraphJastrow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -45,29 +38,27 @@ def setUp(self):
         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 = JastrowFactorGraph(self.mol,
-                                          ee_model=MGCNPredictor,
-                                          ee_model_kwargs={'n_layers': 3,
-                                                           'feats': 32,
-                                                           'cutoff': 5.0,
-                                                           'gap': 1.},
-                                          en_model=MGCNPredictor,
-                                          en_model_kwargs={'n_layers': 3,
-                                                           'feats': 32,
-                                                           'cutoff': 5.0,
-                                                           'gap': 1.0})
+        self.mol = SimpleNamespace(
+            nup=self.nup,
+            ndown=self.ndown,
+            atom_coords=self.atomic_pos,
+            atoms=self.atom_types,
+        )
+
+        self.jastrow = JastrowFactorGraph(
+            self.mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
 
         self.nbatch = 5
 
-        self.pos = -1. + 2*torch.rand(self.nbatch, self.nelec * 3)
+        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
@@ -76,54 +67,41 @@ def test_permutation(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)
 
         jval_xup = self.jastrow(pos_xup)
-        assert(torch.allclose(jval, jval_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 = 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_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, dval_grad.transpose(1, 2))
-        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, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
 
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index e53b5216..a68ad541 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -4,10 +4,19 @@
 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,
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -15,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]
 
@@ -37,9 +41,7 @@ def hess(out, pos):
 
 
 class TestJastrowCombinedTerms(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -48,20 +50,18 @@ def setUp(self):
         self.atoms = np.random.rand(4, 3)
 
         self.mol = SimpleNamespace(
-            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
 
         self.jastrow = JastrowFactorCombinedTerms(
             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
 
@@ -72,30 +72,23 @@ def test_jastrow(self):
         val = 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/test_backflow_kernel_generic_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
index 4be0c43f..1c7fd230 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -8,7 +8,10 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
+from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import (
+    ElectronElectronDistance,
+)
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -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,36 +38,29 @@ 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 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,16 +78,11 @@ def _backflow_kernel(self, ree):
 
 
 class TestGenericBackFlowKernel(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 kernel
         self.kernel = GenericBackFlowKernel(self.mol)
@@ -111,20 +96,21 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
+        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_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))
+        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."""
+        wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -133,8 +119,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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))
+        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.
@@ -156,8 +142,7 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
+        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
@@ -170,16 +155,14 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
+        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))
+        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.
@@ -206,29 +189,30 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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()))
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
 
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
+        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
 
 
 if __name__ == "__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 0001d1cd..e9a4c6aa 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -7,7 +7,10 @@
 
 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.wavefunction.jastrows.distance.electron_electron_distance import (
+    ElectronElectronDistance,
+)
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -15,24 +18,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]
 
@@ -40,39 +37,27 @@ 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 TestBackFlowKernel(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 kernel
         self.kernel = BackFlowKernelInverse(self.mol)
@@ -86,20 +71,21 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
+        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_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))
+        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."""
+        wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -108,8 +94,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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))
+        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.
@@ -131,8 +117,7 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
+        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
@@ -145,16 +130,14 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
+        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))
+        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.
@@ -181,29 +164,30 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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()))
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
 
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
+        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index 4334c918..a2fc1efd 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -5,8 +5,11 @@
 from torch.autograd import Variable, grad, gradcheck
 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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -14,24 +17,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]
 
@@ -39,43 +36,30 @@ 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 TestBackFlowTransformation(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 backflow transformation
-        self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse)
+        self.backflow_trans = BackFlowTransformation(self.mol, BackFlowKernelInverse)
 
         # define the grid points
         self.npts = 11
@@ -95,18 +79,17 @@ def test_backflow_derivative(self):
 
         # 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]
+        dq_grad = grad(q, self.pos, grad_outputs=torch.ones_like(self.pos))[0]
 
         # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
+        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))
+        assert torch.allclose(dq, dq_grad)
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -123,14 +106,14 @@ def test_backflow_second_derivative(self):
         d2q_auto = hess(q, self.pos)
 
         # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
+        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))
+        assert torch.allclose(d2q, d2q_auto)
 
 
 if __name__ == "__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 eb5d1d03..7d06f969 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
@@ -5,8 +5,11 @@
 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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -14,24 +17,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]
 
@@ -39,43 +36,32 @@ 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 TestOrbitalDependentBackFlowTransformation(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 backflow transformation
         self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # set the weights to random
         for ker in self.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -104,21 +90,23 @@ def test_backflow_derivative(self):
         for iq in range(nao):
             qao = q[:, iq, ...]
             dqao = grad(
-                qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True)[0]
+                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)
+                    (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis
+                )
         # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
+        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))
+        assert torch.allclose(dq, dq_grad)
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -141,18 +129,19 @@ def test_backflow_second_derivative(self):
                 d2q_auto = d2qao
             else:
                 d2q_auto = torch.cat(
-                    (d2q_auto, d2qao), axis=self.backflow_trans.backflow_kernel.stack_axis)
+                    (d2q_auto, d2qao),
+                    axis=self.backflow_trans.backflow_kernel.stack_axis,
+                )
 
         # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
+        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)
+        d2q_auto = d2q_auto.reshape(self.npts, nao, self.mol.nelec, 3)
 
-        assert(torch.allclose(d2q, d2q_auto))
+        assert torch.allclose(d2q, d2q_auto)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index dd06a9fc..df4d0671 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -6,21 +6,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]
 
@@ -28,92 +23,77 @@ 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 BaseTestAO:
-
     class BaseTestAOderivatives(unittest.TestCase):
-
         def setUp(self):
             self.ao = None
             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]
+            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()))
+            assert torch.allclose(dao.sum(), dao_grad.sum())
 
         def test_ao_grad_sum(self):
-
             ao = 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)))
+            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()))
+            assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
 
         def test_ao_hess_sum(self):
-
             ao = 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)))
+            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])
+            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)
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 6038d514..0ca0a892 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -9,17 +9,16 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
index b4f06eb8..b3389f02 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
@@ -8,23 +8,19 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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')
+        at = "Li 0 0 0; H 0 0 1"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the aos
         self.ao = AtomicOrbitals(self.mol)
diff --git a/tests/wavefunction/orbitals/test_ao_values_adf.py b/tests/wavefunction/orbitals/test_ao_values_adf.py
index 7537109d..774159f7 100644
--- a/tests/wavefunction/orbitals/test_ao_values_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_adf.py
@@ -16,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
 
 
@@ -33,52 +33,46 @@ 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
@@ -94,17 +88,13 @@ def setUp(self):
         self.pos.requires_grad = True
 
     def test_ao(self):
-
         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)
 
@@ -119,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 8215619d..a4c6642e 100644
--- a/tests/wavefunction/orbitals/test_ao_values_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
@@ -13,18 +13,13 @@
 
 
 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.ao = AtomicOrbitals(self.mol)
@@ -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.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.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 c4a19bc5..9bb50ff1 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -6,9 +6,14 @@
 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.backflow.backflow_transformation import BackFlowTransformation
+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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -16,24 +21,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,42 +40,31 @@ 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -94,53 +82,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..487883b4 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -8,24 +8,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,69 +27,59 @@ 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):
@@ -105,14 +89,12 @@ def test_value(self):
     def test_grad(self):
         xyz, r = 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()
@@ -120,8 +102,7 @@ def test_jac(self):
         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()
@@ -129,8 +110,7 @@ def test_lap(self):
         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()
@@ -138,8 +118,7 @@ def test_mixed_der(self):
         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 0280b0d1..aa09cfbd 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -11,29 +11,24 @@
 
 
 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.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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -43,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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -70,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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        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)
@@ -131,11 +119,9 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.harmonics(
-            xyz, derivative=[0, 1, 2], sum_grad=False)
+        R, dR, 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)
 
@@ -143,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]
@@ -157,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)
@@ -172,13 +157,11 @@ def test_lap_sum(self):
         npts = 100
         self.pos = torch.rand(npts, self.mol.nelec * 3)
         xyz, r = self.ao._process_position(self.pos)
-        d2R_sum = self.ao.harmonics(
-            xyz, derivative=2, sum_hess=True)
+        d2R_sum = self.ao.harmonics(xyz, derivative=2, sum_hess=True)
 
-        d2R = self.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 331cdfe5..73841d09 100644
--- a/tests/wavefunction/orbitals/test_mo_values_adf.py
+++ b/tests/wavefunction/orbitals/test_mo_values_adf.py
@@ -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()
 
         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 d2351fd3..0c00b0db 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
@@ -6,9 +6,14 @@
 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.backflow.backflow_transformation import BackFlowTransformation
+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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -16,24 +21,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 +40,32 @@ 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
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -99,53 +87,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..22ada5f6 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,16 +77,15 @@ 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):
@@ -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 b7e90ebe..26e3ee7a 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -10,33 +10,35 @@
 
 
 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.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.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, 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()
@@ -46,28 +48,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.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, 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()
@@ -77,48 +80,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.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, 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)
@@ -139,14 +140,16 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = z
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(r, self.ao.bas_n,
-                                    self.ao.bas_exp,
-                                    xyz=xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False)
+        R, dR, 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)
 
@@ -154,8 +157,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]
@@ -171,10 +174,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 9883c120..9f28fbb1 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -12,32 +12,31 @@
 
 
 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.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.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, 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()
@@ -47,28 +46,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.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, 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()
@@ -78,48 +78,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.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, 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)
@@ -141,23 +139,25 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(r, self.ao.bas_n,
-                                    self.ao.bas_exp,
-                                    xyz=xyz,
-                                    derivative=[0, 1, 2],
-                                    sum_grad=False)
+        R, dR, 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]
@@ -170,12 +170,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..1451cfd2 100644
--- a/tests/wavefunction/orbitals/test_spherical_harmonics.py
+++ b/tests/wavefunction/orbitals/test_spherical_harmonics.py
@@ -7,12 +7,11 @@
 
 
 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/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 8baf5130..dc18ba52 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -9,72 +9,73 @@
 
 
 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.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.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 5c7f874e..33abb837 100644
--- a/tests/wavefunction/pooling/test_trace_trick.py
+++ b/tests/wavefunction/pooling/test_trace_trick.py
@@ -30,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
 
@@ -64,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]
 
@@ -98,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]
 
@@ -134,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
@@ -150,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)
 
@@ -170,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]
 
@@ -207,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]
 
@@ -229,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):
@@ -247,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
@@ -272,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
@@ -288,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 992a0c2a..1ff3cbc6 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -5,11 +5,17 @@
 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.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.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
 
@@ -17,9 +23,7 @@
 
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,43 +31,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)
+            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,)
+            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.
-
-        self.wf_ref = SlaterJastrow(mol,
-                                    kinetic='jacobi',
-                                    include_all_mo=True,
-                                    configs='single_double(2,2)',
-                                    jastrow=jastrow,
-                                    backflow=None)
+            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):
@@ -71,43 +82,38 @@ 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)))
+        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__":
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index e70762d7..487d8b05 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -5,11 +5,17 @@
 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.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.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
 
@@ -17,9 +23,7 @@
 
 
 class TestCompareSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,44 +31,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)
+            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)
+        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)
+            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)',
-                                    jastrow=jastrow,
-                                    backflow=None)
+        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):
@@ -72,43 +80,38 @@ 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)))
+        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__":
diff --git a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
index 6f899ae4..11ca4c4c 100644
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -15,21 +15,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]
 
@@ -37,9 +32,7 @@ def hess(out, pos):
 
 
 class TestSlaterJastrowGraph(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -47,35 +40,33 @@ 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)
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         # jastrow
-        jastrow = JastrowFactor(mol,
-                                ee_model=MGCNPredictor,
-                                ee_model_kwargs={'n_layers': 3,
-                                                 'feats': 32,
-                                                 'cutoff': 5.0,
-                                                 'gap': 1.},
-                                en_model=MGCNPredictor,
-                                en_model_kwargs={'n_layers': 3,
-                                                 'feats': 32,
-                                                 'cutoff': 5.0,
-                                                 'gap': 1.0})
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow)
+        jastrow = JastrowFactor(
+            mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
+        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):
@@ -88,8 +79,10 @@ def test_antisymmetry(self):
 
         if self.wf.nelec < 4:
             print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
+                "Warning : antisymmetry cannot be tested with \
+                    only %d electrons"
+                % self.wf.nelec
+            )
             return
 
         # test spin up
@@ -98,23 +91,21 @@ def test_antisymmetry(self):
         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)
+        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))
+        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
+        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)
+        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))
+        assert torch.allclose(wfvals_ref, -1 * wfvals_xdn)
 
     def test_grad_mo(self):
         """Gradients of the MOs."""
@@ -122,16 +113,14 @@ def test_grad_mo(self):
         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]
+        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)))
+        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."""
@@ -140,47 +129,43 @@ def test_hess_mo(self):
         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(), 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).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)))
+        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)
+        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)
+        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()
+        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))
+        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)
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 4597fb45..59355b19 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -7,19 +7,25 @@
 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
+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,
+)
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,33 +33,35 @@ 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)
+            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.},
-                                                 'en': {'w': 1.},
-                                                 'een': {}})
+        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.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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 6d4c55f5..fbb9a6aa 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -7,13 +7,25 @@
 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.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
 
@@ -22,9 +34,7 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -32,40 +42,41 @@ 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.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.},
-                                                 'en': {'w': 1.},
-                                                 'een': {}})
+        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)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='jacobi',
-                                include_all_mo=True,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=backflow)
+        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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_internal.py b/tests/wavefunction/test_slatercombinedjastrow_internal.py
index 861cc674..661a25b3 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_internal.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_internal.py
@@ -7,17 +7,21 @@
 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
+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)
 
@@ -25,27 +29,29 @@ 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)
+            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.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 = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
 
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index d1f2e600..d8a4b0ee 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -9,7 +8,9 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
@@ -20,9 +21,7 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -30,28 +29,29 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=None)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 7f2ac909..3c07b012 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -9,7 +9,10 @@
 
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 
 from qmctorch.utils import set_torch_double_precision
 
@@ -18,9 +21,7 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -28,33 +29,33 @@ 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.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         # define jastrow factor
-        jastrow = JastrowFactor(
-            mol, PadeJastrowKernel)
+        jastrow = JastrowFactor(mol, PadeJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='jacobi',
-                                include_all_mo=True,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=backflow)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index 7a40c1b8..3a47cd59 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -7,7 +7,9 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
@@ -16,9 +18,7 @@
 
 
 class TestSlaterJastrowCAS(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -26,28 +26,29 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=True,
-                                configs='cas(2,2)',
-                                jastrow=jastrow)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index 4dc1ffbc..75b0937c 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -8,17 +8,20 @@
 
 from qmctorch.utils import set_torch_double_precision
 
-from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel, PadeJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import (
+    FullyConnectedJastrowKernel,
+    PadeJastrowKernel,
+)
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestSlaterJastrowElectronCusp(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -26,38 +29,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)
-
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel)
-
-        self.wf = SlaterJastrow(mol,
-                                jastrow=jastrow,
-                                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()
@@ -65,10 +69,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 66fbdacf..1a715044 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -8,11 +8,17 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
-from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
+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
 
@@ -21,9 +27,7 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -31,32 +35,32 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=None)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 9072b9c5..443f1419 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -1,5 +1,3 @@
-
-
 import numpy as np
 import torch
 import unittest
@@ -9,11 +7,17 @@
 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.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.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
 
@@ -21,10 +25,10 @@
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrowOrbitalDependentBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
+class TestSlaterJastrowOrbitalDependentBackFlow(
+    BaseTestCases.BackFlowWaveFunctionBaseTest
+):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -32,26 +36,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)
+            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)
+        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)
+            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:
@@ -61,8 +68,7 @@ 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
 
 
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index e50a2ae4..3132514e 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -10,14 +10,15 @@
 from qmctorch.solver import SolverMPI
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 from qmctorch.utils import set_torch_double_precision
 
 
 class TestH2Hvd(unittest.TestCase):
-
     def setUp(self):
         hvd.init()
 
@@ -32,22 +33,21 @@ 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",
             rank=hvd.local_rank(),
-            mpi_size=hvd.local_size())
+            mpi_size=hvd.local_size(),
+        )
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(
-            self.mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='cas(2,2)',
-                                jastrow=jastrow,
-                                cuda=False)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=False
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -56,17 +56,17 @@ def setUp(self):
             step_size=0.2,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('atomic'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("atomic"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverMPI(wf=self.wf, sampler=self.sampler,
-                                                 optimizer=self.opt, rank=hvd.rank())
+        self.solver = SolverMPI(
+            wf=self.wf, sampler=self.sampler, optimizer=self.opt, rank=hvd.rank()
+        )
 
         # ground state energy
         self.ground_state_energy = -1.16
@@ -92,17 +92,20 @@ def test_wf_opt(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.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                              loss='energy', grad='auto',
-                              ortho_mo=False, clip_loss=False,
-                              resampling={'mode': 'update',
-                                          'resample_every': 1,
-                                          'nstep_update': 50})
+        self.solver.configure(
+            track=["local_energy"],
+            freeze=["ao", "mo"],
+            loss="energy",
+            grad="auto",
+            ortho_mo=False,
+            clip_loss=False,
+            resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+        )
         self.solver.run(10)
 
         MPI.COMM_WORLD.barrier()
 
-        self.solver.wf.load(self.solver.hdf5file, 'wf_opt')
+        self.solver.wf.load(self.solver.hdf5file, "wf_opt")
         self.solver.wf.eval()
 
         obs = self.solver.single_point()

From 021b52f20bf684498f142e59a19ee89c0a2ce09f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 14:26:08 +0100
Subject: [PATCH 095/286] Revert "reformat black"

This reverts commit fef65644d08f5e26fb6a165ab420abed185ccde0.
---
 docs/conf.py                                  | 146 ++++----
 docs/example/autocorrelation/h2.py            |  28 +-
 docs/example/backflow/backflow.py             |  27 +-
 docs/example/gpu/h2.py                        |  65 ++--
 docs/example/horovod/h2.py                    |  69 ++--
 docs/example/jast_graph.py                    |   6 +-
 docs/example/optimization/h2.py               |  58 ++--
 docs/example/scf/scf.py                       |  21 +-
 docs/example/single_point/h2.py               |  26 +-
 docs/example/single_point/h2o_sampling.py     |  29 +-
 h5x/baseimport.py                             |   6 +-
 qmctorch/__init__.py                          |   5 +-
 qmctorch/__version__.py                       |   2 +-
 qmctorch/sampler/__init__.py                  |  13 +-
 qmctorch/sampler/generalized_metropolis.py    |  77 ++---
 qmctorch/sampler/hamiltonian.py               |  57 ++--
 qmctorch/sampler/metropolis.py                | 147 ++++----
 qmctorch/sampler/metropolis_all_elec.py       | 102 +++---
 .../sampler/metropolis_hasting_all_elec.py    |  79 +++--
 qmctorch/sampler/pints_sampler.py             |  59 ++--
 qmctorch/sampler/proposal_kernels.py          |  15 +-
 qmctorch/sampler/sampler_base.py              |  40 ++-
 .../state_dependent_normal_proposal.py        |  18 +-
 qmctorch/sampler/walkers.py                   |  70 ++--
 qmctorch/scf/__init__.py                      |   2 +-
 qmctorch/scf/calculator/__init__.py           |   2 +-
 qmctorch/scf/calculator/adf.py                | 168 +++++----
 qmctorch/scf/calculator/calculator_base.py    |  21 +-
 qmctorch/scf/calculator/pyscf.py              |  83 ++---
 qmctorch/scf/molecule.py                      | 290 ++++++++--------
 qmctorch/solver/__init__.py                   |   3 +-
 qmctorch/solver/solver.py                     | 184 +++++-----
 qmctorch/solver/solver_base.py                | 316 +++++++++--------
 qmctorch/solver/solver_mpi.py                 | 140 ++++----
 qmctorch/utils/__init__.py                    |  65 ++--
 qmctorch/utils/algebra_utils.py               |  15 +-
 qmctorch/utils/hdf5_utils.py                  | 135 ++++----
 qmctorch/utils/interpolate.py                 | 169 +++++-----
 qmctorch/utils/plot_data.py                   | 108 +++---
 qmctorch/utils/stat_utils.py                  |   8 +-
 qmctorch/utils/torch_utils.py                 |  76 +++--
 qmctorch/wavefunction/__init__.py             |   6 +-
 .../wavefunction/jastrows/combine_jastrow.py  |  73 ++--
 .../distance/electron_electron_distance.py    |  51 +--
 .../distance/electron_nuclei_distance.py      |  36 +-
 .../wavefunction/jastrows/distance/scaling.py |   4 +-
 .../jastrows/elec_elec/__init__.py            |   4 +-
 .../jastrow_factor_electron_electron.py       |  79 ++---
 .../kernels/fully_connected_jastrow_kernel.py |  53 +--
 .../jastrow_kernel_electron_electron_base.py  |  15 +-
 .../elec_elec/kernels/pade_jastrow_kernel.py  |  43 +--
 .../kernels/pade_jastrow_polynomial_kernel.py |  60 ++--
 .../orbital_dependent_jastrow_kernel.py       |  28 +-
 .../jastrows/elec_elec_nuclei/__init__.py     |   4 +-
 ...jastrow_factor_electron_electron_nuclei.py |  89 +++--
 .../elec_elec_nuclei/kernels/__init__.py      |   4 +-
 .../kernels/boys_handy_jastrow_kernel.py      |  15 +-
 .../kernels/fully_connected_jastrow_kernel.py |  11 +-
 ...ow_kernel_electron_electron_nuclei_base.py |  30 +-
 .../jastrow_factor_electron_nuclei.py         |  43 ++-
 .../kernels/fully_connected_jastrow_kernel.py |   5 +-
 .../jastrow_kernel_electron_nuclei_base.py    |  15 +-
 .../kernels/pade_jastrow_kernel.py            |  26 +-
 .../jastrows/graph/elec_elec_graph.py         |  10 +-
 .../jastrows/graph/elec_nuc_graph.py          |  26 +-
 .../jastrows/graph/jastrow_graph.py           | 120 +++----
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  |  50 ++-
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  45 +--
 .../jastrows/jastrow_factor_combined_terms.py | 153 ++++-----
 .../wavefunction/orbitals/atomic_orbitals.py  | 239 ++++++-------
 .../orbitals/atomic_orbitals_backflow.py      |  77 ++---
 ...mic_orbitals_orbital_dependent_backflow.py |  80 ++---
 .../backflow/backflow_transformation.py       | 133 ++++----
 .../backflow_kernel_autodiff_inverse.py       |  10 +-
 .../backflow/kernels/backflow_kernel_base.py  |  17 +-
 .../backflow_kernel_fully_connected.py        |   3 +-
 .../kernels/backflow_kernel_inverse.py        |  12 +-
 .../kernels/backflow_kernel_power_sum.py      |   5 +-
 .../kernels/backflow_kernel_square.py         |   8 +-
 .../orbital_dependent_backflow_kernel.py      |  11 +-
 ...bital_dependent_backflow_transformation.py |  75 ++--
 .../wavefunction/orbitals/norm_orbital.py     |  88 ++---
 .../wavefunction/orbitals/radial_functions.py | 229 ++++++-------
 .../orbitals/spherical_harmonics.py           | 319 +++++++-----------
 .../pooling/orbital_configurations.py         | 132 ++++----
 .../wavefunction/pooling/orbital_projector.py |  89 ++---
 .../wavefunction/pooling/slater_pooling.py    | 283 +++++++---------
 qmctorch/wavefunction/slater_jastrow.py       | 199 ++++++-----
 .../slater_orbital_dependent_jastrow.py       |  77 ++---
 .../trash/slater_combined_jastrow.py          |  58 ++--
 .../trash/slater_combined_jastrow_backflow.py | 108 +++---
 qmctorch/wavefunction/trash/slater_jastrow.py |  45 ++-
 .../trash/slater_jastrow_backflow.py          |  89 +++--
 .../wavefunction/trash/slater_jastrow_base.py | 164 +++++----
 .../trash/slater_jastrow_graph.py             |  57 ++--
 qmctorch/wavefunction/wf_base.py              | 113 ++++---
 setup.py                                      |  72 ++--
 tests/path_utils.py                           |   2 +-
 tests/sampler/test_generalized_metropolis.py  |  11 +-
 tests/sampler/test_hamiltonian.py             |   4 +-
 tests/sampler/test_metropolis.py              |  23 +-
 tests/sampler/test_metropolis_hasting.py      |  16 +-
 tests/sampler/test_pints.py                   |  11 +-
 tests/sampler/test_sampler_base.py            |  18 +-
 tests/sampler/test_walker.py                  |  25 +-
 tests/scf/test_gto2sto_fit.py                 |  55 ++-
 tests/scf/test_molecule.py                    |  55 +--
 tests/solver/test_base_solver.py              |  15 +-
 tests/solver/test_h2_adf.py                   |  27 +-
 tests/solver/test_h2_adf_jacobi.py            |  26 +-
 tests/solver/test_h2_pyscf_geo_opt.py         |  55 +--
 tests/solver/test_h2_pyscf_hamiltonian.py     |  29 +-
 tests/solver/test_h2_pyscf_jacobi.py          |  29 +-
 tests/solver/test_h2_pyscf_metropolis.py      |  50 +--
 tests/solver/test_h2_pyscf_stats.py           |  39 +--
 tests/solver/test_lih_adf_backflow.py         |  42 ++-
 tests/solver/test_lih_correlated.py           |  34 +-
 tests/solver/test_lih_pyscf.py                |  31 +-
 tests/solver/test_lih_pyscf_backflow.py       |  48 ++-
 .../solver/test_lih_pyscf_compare_backflow.py | 125 ++++---
 .../solver/test_lih_pyscf_generic_backflow.py |  48 ++-
 .../solver/test_lih_pyscf_generic_jastrow.py  |  40 ++-
 ...st_lih_pyscf_orbital_dependent_backflow.py |  48 ++-
 tests/utils/test_interpolate.py               |  36 +-
 tests/wavefunction/base_test_cases.py         | 110 +++---
 .../distance/test_elec_elec_distance.py       |  21 +-
 .../elec_elec/base_elec_elec_jastrow_test.py  |  62 ++--
 .../elec_elec/test_generic_jastrow.py         |  17 +-
 .../jastrows/elec_elec/test_pade_jastrow.py   |  15 +-
 .../elec_elec/test_pade_jastrow_polynom.py    |  23 +-
 .../elec_elec/test_scaled_pade_jastrow.py     |  16 +-
 .../test_scaled_pade_jastrow_polynom.py       |  25 +-
 .../jastrows/elec_elec_nuc/test_hess.py       |  16 +-
 .../test_three_body_jastrow_boys_handy.py     |  83 +++--
 ...test_three_body_jastrow_fully_connected.py |  77 +++--
 .../test_electron_nuclei_fully_connected.py   |  54 +--
 .../test_electron_nuclei_pade_jastrow.py      |  54 +--
 .../jastrows/graph/test_graph_jastrow.py      |  80 +++--
 .../jastrows/test_combined_terms.py           |  65 ++--
 .../test_backflow_kernel_generic_pyscf.py     | 104 +++---
 .../test_backflow_kernel_inverse_pyscf.py     |  96 +++---
 .../test_backflow_transformation_pyscf.py     |  55 +--
 ...dependent_backflow_transformation_pyscf.py |  65 ++--
 tests/wavefunction/orbitals/base_test_ao.py   |  72 ++--
 .../orbitals/second_derivative.py             |   1 +
 .../orbitals/test_ao_derivatives_adf.py       |   5 +-
 .../orbitals/test_ao_derivatives_pyscf.py     |  12 +-
 .../orbitals/test_ao_values_adf.py            |  60 ++--
 .../orbitals/test_ao_values_pyscf.py          |  35 +-
 .../test_backflow_ao_derivatives_pyscf.py     |  77 +++--
 .../orbitals/test_cartesian_harmonics.py      |  73 ++--
 .../orbitals/test_cartesian_harmonics_adf.py  |  57 ++--
 .../orbitals/test_mo_values_adf.py            |  51 +--
 tests/wavefunction/orbitals/test_norm.py      |  21 +-
 ...dependent_backflow_ao_derivatives_pyscf.py |  77 +++--
 .../orbitals/test_radial_functions.py         | 118 ++++---
 .../wavefunction/orbitals/test_radial_gto.py  |  96 +++---
 .../wavefunction/orbitals/test_radial_sto.py  |  93 ++---
 .../orbitals/test_spherical_harmonics.py      |   3 +-
 tests/wavefunction/pooling/test_orbconf.py    |  20 +-
 tests/wavefunction/pooling/test_slater.py     |  57 ++--
 .../wavefunction/pooling/test_trace_trick.py  | 114 ++++---
 .../test_compare_slaterjastrow_backflow.py    |  88 +++--
 ...laterjastrow_orbital_dependent_backflow.py |  81 +++--
 .../test_slater_mgcn_graph_jastrow.py         | 119 ++++---
 .../test_slatercombinedjastrow.py             |  62 ++--
 .../test_slatercombinedjastrow_backflow.py    |  77 ++---
 .../test_slatercombinedjastrow_internal.py    |  38 +--
 tests/wavefunction/test_slaterjastrow.py      |  38 +--
 .../test_slaterjastrow_backflow.py            |  41 ++-
 tests/wavefunction/test_slaterjastrow_cas.py  |  35 +-
 .../test_slaterjastrow_ee_cusp.py             |  64 ++--
 .../test_slaterjastrow_generic.py             |  48 ++-
 ...laterjastrow_orbital_dependent_backflow.py |  56 ++-
 tests_hvd/test_h2_hvd.py                      |  55 ++-
 175 files changed, 5400 insertions(+), 5264 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 58c16090..f9cac9b1 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -59,33 +59,32 @@
 
 
 autodoc_mock_imports = [
-    "numpy",
-    "scipy",
-    "h5py",
-    "twiggy",
-    "mpi4py",
-    "scipy.signal",
-    "torch",
-    "torch.utils",
-    "torch.utils.data",
-    "matplotlib",
-    "matplotlib.pyplot",
-    "torch.autograd",
-    "torch.nn",
-    "torch.optim",
-    "torch.cuda",
-    "torch.distributions",
-    "mendeleev",
-    "pandas",
-    "pyscf",
-    "adf",
-    "scm",
-    "tqdm",
-    "ase",
-    "horovod",
-]
-
-sys.path.insert(0, os.path.abspath("../"))
+    'numpy',
+    'scipy',
+    'h5py',
+    'twiggy',
+    'mpi4py',
+    'scipy.signal',
+    'torch',
+    'torch.utils',
+    'torch.utils.data',
+    'matplotlib',
+    'matplotlib.pyplot',
+    'torch.autograd',
+    'torch.nn',
+    'torch.optim',
+    'torch.cuda',
+    'torch.distributions',
+    'mendeleev',
+    'pandas',
+    'pyscf',
+    'adf',
+    'scm',
+    'tqdm',
+    'ase',
+    'horovod']
+
+sys.path.insert(0, os.path.abspath('../'))
 
 
 # -- General configuration ------------------------------------------------
@@ -98,58 +97,58 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.doctest",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.todo",
-    "sphinx.ext.coverage",
-    "sphinx.ext.mathjax",
-    "sphinx.ext.ifconfig",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.viewcode",
-    "nbsphinx",
+    'sphinx.ext.autodoc',
+    'sphinx.ext.doctest',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.ifconfig',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'nbsphinx'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "QMCTorch"
-copyright = "2020, Nicolas Renaud"
-author = "Nicolas Renaud"
+project = 'QMCTorch'
+copyright = '2020, Nicolas Renaud'
+author = 'Nicolas Renaud'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = "0.1"
+version = '0.1'
 # The full version, including alpha/beta/rc tags.
-release = "0.1.0"
+release = '0.1.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = "en"
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+pygments_style = 'sphinx'
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -166,7 +165,7 @@
 # else:
 #     html_theme = 'classic'
 
-html_theme = "sphinx_rtd_theme"
+html_theme = 'sphinx_rtd_theme'
 html_logo = "./pics/qmctorch_white.png"
 
 # Theme options are theme-specific and customize the look and feel of a theme
@@ -181,7 +180,7 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -189,11 +188,11 @@
 # This is required for the alabaster theme
 # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
 html_sidebars = {
-    "**": [
-        "globaltoc.html",
-        "relations.html",  # needs 'show_related': True theme option to display
-        "sourcelink.html",
-        "searchbox.html",
+    '**': [
+        'globaltoc.html',
+        'relations.html',  # needs 'show_related': True theme option to display
+        'sourcelink.html',
+        'searchbox.html',
     ]
 }
 
@@ -201,7 +200,7 @@
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "QMCTorchdoc"
+htmlhelp_basename = 'QMCTorchdoc'
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -210,12 +209,15 @@
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
+
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
+
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
+
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -225,7 +227,8 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "QMCTorch.tex", "QMCTorch Documentation", "Nicolas Renaud", "manual"),
+    (master_doc, 'QMCTorch.tex', 'QMCTorch Documentation',
+     'Nicolas Renaud', 'manual'),
 ]
 
 
@@ -233,7 +236,10 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "qmctorch", "QMCTorch Documentation", [author], 1)]
+man_pages = [
+    (master_doc, 'qmctorch', 'QMCTorch Documentation',
+     [author], 1)
+]
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -242,24 +248,18 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
-        master_doc,
-        "QMCTorch",
-        "QMCTorch Documentation",
-        author,
-        "QMCTorch",
-        "One line description of project.",
-        "Miscellaneous",
-    ),
+    (master_doc, 'QMCTorch', 'QMCTorch Documentation',
+     author, 'QMCTorch', 'One line description of project.',
+     'Miscellaneous'),
 ]
 
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {
-    "python": ("https://docs.python.org/", None),
-    "numpy": ("http://docs.scipy.org/doc/numpy/", None),
-    "pytorch": ("http://pytorch.org/docs/1.4.0/", None),
+    'python': ('https://docs.python.org/', None),
+    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
+    'pytorch': ('http://pytorch.org/docs/1.4.0/', None),
 }
 
-autoclass_content = "init"
-autodoc_member_order = "bysource"
-nbsphinx_allow_errors = True
+autoclass_content = 'init'
+autodoc_member_order = 'bysource'
+nbsphinx_allow_errors = True
\ No newline at end of file
diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index f27ffeaa..6c7ca9c9 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -4,26 +4,26 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.scf import Molecule
 from qmctorch.solver import Solver
-from qmctorch.utils import (
-    plot_correlation_coefficient,
-    plot_integrated_autocorrelation_time,
-)
+from qmctorch.utils 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"
-)
+    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)")
+wf = SlaterJastrow(mol, kinetic='auto',
+                   jastrow=jastrow,
+                   configs='single(2,2)')
 
 # sampler
 sampler = Metropolis(
@@ -34,9 +34,10 @@
     step_size=0.5,
     ndim=wf.ndim,
     nelec=wf.nelec,
-    init=mol.domain("normal"),
-    move={"type": "all-elec", "proba": "normal"},
-)
+    init=mol.domain('normal'),
+    move={
+        'type': 'all-elec',
+        'proba': 'normal'})
 
 opt = optim.Adam(wf.parameters(), lr=0.01)
 
@@ -46,6 +47,7 @@
 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'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 dd388495..abc4de98 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -13,6 +13,7 @@
 
 
 class MyBackflow(BackFlowKernelBase):
+
     def __init__(self, mol, cuda, size=16):
         super().__init__(mol, cuda)
         self.fc1 = nn.Linear(1, size, bias=False)
@@ -26,28 +27,20 @@ def forward(self, x):
 
 
 # define the molecule
-mol = Molecule(
-    atom="Li 0. 0. 0.; H 3.14 0. 0.",
-    unit="angs",
-    calculator="pyscf",
-    basis="sto-3g",
-    name="LiH",
-)
+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})
+backflow = BackFlowTransformation(mol, MyBackflow, {'size': 64})
 
 # define the wave function
-wf = SlaterJastrow(
-    mol,
-    kinetic="jacobi",
-    jastrow=jastrow,
-    backflow=backflow,
-    configs="single_double(2,2)",
-)
-
-pos = torch.rand(10, wf.nelec * 3)
+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 fcbaf1ef..755441ff 100644
--- a/docs/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -6,7 +6,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import plot_energy, plot_data
+from qmctorch.utils import (plot_energy, plot_data)
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -16,65 +16,58 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69", calculator="adf", basis="dzp", unit="bohr"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='adf',
+               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
-)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='cas(2,2)',
+                   jastrow=jastrow,
+                   cuda=True)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=2000,
-    nstep=2000,
-    step_size=0.2,
-    ntherm=-1,
-    ndecor=100,
-    nelec=wf.nelec,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-    cuda=True,
-)
+sampler = Metropolis(nwalkers=2000,
+                     nstep=2000, step_size=0.2,
+                     ntherm=-1, ndecor=100,
+                     nelec=wf.nelec, init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'},
+                     cuda=True)
 
 
 # optimizer
-lr_dict = [
-    {"params": wf.jastrow.parameters(), "lr": 3e-3},
-    {"params": wf.ao.parameters(), "lr": 1e-6},
-    {"params": wf.mo.parameters(), "lr": 1e-3},
-    {"params": wf.fc.parameters(), "lr": 2e-3},
-]
-opt = optim.Adam(lr_dict, lr=1e-3)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
+           {'params': wf.ao.parameters(), 'lr': 1E-6},
+           {'params': wf.mo.parameters(), 'lr': 1E-3},
+           {'params': wf.fc.parameters(), 'lr': 2E-3}]
+opt = optim.Adam(lr_dict, lr=1E-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # 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()
 
 # optimize the wave function
 # configure the solver
-solver.configure(
-    track=["local_energy"],
-    freeze=["ao", "mo"],
-    loss="energy",
-    grad="auto",
-    ortho_mo=False,
-    clip_loss=False,
-    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-)
+solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                 loss='energy', grad='auto',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 50})
 
 # optimize the wave function
 obs = solver.run(250)
 
 plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname="jastrow.weight")
+plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/docs/example/horovod/h2.py b/docs/example/horovod/h2.py
index 7ce8207b..4e4b76f3 100644
--- a/docs/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import SolverMPI
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import plot_energy, plot_data
+from qmctorch.utils import (plot_energy, plot_data)
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -22,64 +22,51 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69",
-    unit="bohr",
-    calculator="pyscf",
-    basis="sto-3g",
-    rank=hvd.local_rank(),
-    mpi_size=hvd.local_size(),
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', unit='bohr',
+               calculator='pyscf', basis='sto-3g',
+               rank=hvd.local_rank(), mpi_size=hvd.local_size())
 
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic="jacobi", configs="cas(2,2)", cuda=use_cuda)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='cas(2,2)',
+                   cuda=use_cuda)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=200,
-    nstep=200,
-    step_size=0.2,
-    ntherm=-1,
-    ndecor=100,
-    nelec=wf.nelec,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-    cuda=use_cuda,
-)
+sampler = Metropolis(nwalkers=200,
+                     nstep=200, step_size=0.2,
+                     ntherm=-1, ndecor=100,
+                     nelec=wf.nelec, init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'},
+                     cuda=use_cuda)
 
 
 # optimizer
-lr_dict = [
-    {"params": wf.jastrow.parameters(), "lr": 3e-3},
-    {"params": wf.ao.parameters(), "lr": 1e-6},
-    {"params": wf.mo.parameters(), "lr": 1e-3},
-    {"params": wf.fc.parameters(), "lr": 2e-3},
-]
-opt = optim.Adam(lr_dict, lr=1e-3)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
+           {'params': wf.ao.parameters(), 'lr': 1E-6},
+           {'params': wf.mo.parameters(), 'lr': 1E-3},
+           {'params': wf.fc.parameters(), 'lr': 2E-3}]
+opt = optim.Adam(lr_dict, lr=1E-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverMPI(
-    wf=wf, sampler=sampler, optimizer=opt, scheduler=scheduler, rank=hvd.rank()
-)
+solver = SolverMPI(wf=wf, sampler=sampler,
+                                    optimizer=opt, scheduler=scheduler,
+                                    rank=hvd.rank())
 
 # configure the solver
-solver.configure(
-    track=["local_energy"],
-    freeze=["ao", "mo"],
-    loss="energy",
-    grad="auto",
-    ortho_mo=False,
-    clip_loss=False,
-    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-)
+solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                 loss='energy', grad='auto',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 50})
 
 # optimize the wave function
 obs = solver.run(250)
 
 if hvd.rank() == 0:
     plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-    plot_data(solver.observable, obsname="jastrow.weight")
+    plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/docs/example/jast_graph.py b/docs/example/jast_graph.py
index 1dfb4c9b..4df30937 100644
--- a/docs/example/jast_graph.py
+++ b/docs/example/jast_graph.py
@@ -1,12 +1,14 @@
+
 from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
 import torch
 from torch.autograd import grad
-
 nup = 2
 ndown = 2
 atomic_pos = torch.rand(2, 3)
 atom_types = ["Li", "H"]
-jast = JastrowFactorGraph(nup, ndown, atomic_pos, atom_types)
+jast = JastrowFactorGraph(nup, ndown,
+                          atomic_pos,
+                          atom_types)
 
 
 pos = torch.rand(10, 12)
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 41354569..ca6aedac 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils.plot_data import plot_energy, plot_data
+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
 
@@ -21,15 +21,18 @@
 np.random.seed(0)
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69", calculator="pyscf", basis="sto-3g", unit="bohr"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='pyscf',
+               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=jastrow)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='single_double(2,2)',
+                   jastrow=jastrow)
 
 # sampler
 # sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
@@ -37,24 +40,15 @@
 #                       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"),
-)
+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},
-    {"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)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
+           {'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)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
@@ -66,20 +60,14 @@
 # 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,
-    resampling={
-        "mode": "update",
-        "resample_every": 1,
-        "nstep_update": 150,
-        "ntherm_update": 50,
-    },
-)
+solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
+                 loss='energy', grad='manual',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 150,
+                             'ntherm_update': 50}
+                 )
 
 # optimize the wave function
 obs = solver.run(5)  # , batchsize=10)
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index 48d7656e..a609f866 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -1,12 +1,23 @@
 from qmctorch.scf import Molecule
 
 # Select the SCF calculator
-calc = ["pyscf", "adf", "adf2019"][1]  # pyscf  # adf 2019  # adf 2020+
+calc = ['pyscf',            # pyscf  
+        'adf',          # adf 2019 
+        'adf2019'               # adf 2020+
+    ][1]
 
 # select an appropriate basis
-basis = {"pyscf": "sto-6g", "adf": "VB1", "adf2019": "dz"}[calc]
+basis = {
+    'pyscf'  : 'sto-6g',
+    'adf'    : 'VB1',
+    'adf2019': 'dz'
+}[calc]
 
 # do the scf calculation
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69", calculator=calc, basis=basis, unit="bohr"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+            calculator=calc,
+            basis=basis,
+            unit='bohr')
+
+
+
diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
index 5f8126f1..27017364 100644
--- a/docs/example/single_point/h2.py
+++ b/docs/example/single_point/h2.py
@@ -4,33 +4,25 @@
 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"
-)
+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()
+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,
-)
+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)
diff --git a/docs/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
index d07b3086..507a78cb 100644
--- a/docs/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -7,31 +7,22 @@
 
 
 # define the molecule
-mol = Molecule(
-    atom="water.xyz",
-    unit="angs",
-    calculator="pyscf",
-    basis="sto-3g",
-    name="water",
-    redo_scf=True,
-)
+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", jastrow=jastrow)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='ground_state', jastrow=jastrow)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=1000,
-    nstep=500,
-    step_size=0.25,
-    nelec=wf.nelec,
-    ndim=wf.ndim,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-)
+sampler = Metropolis(nwalkers=1000, nstep=500, step_size=0.25,
+                     nelec=wf.nelec, ndim=wf.ndim,
+                     init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'})
 
 # solver
 solver = Solver(wf=wf, sampler=sampler)
@@ -46,4 +37,4 @@
 # compute the sampling traj
 pos = solver.sampler(solver.wf.pdf)
 obs = solver.sampling_traj(pos)
-plot_walkers_traj(obs.local_energy, walkers="mean")
+plot_walkers_traj(obs.local_energy, walkers='mean')
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index a40f53e8..44339111 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,9 +1,5 @@
 from qmctorch.utils.plot_data import (
-    plot_energy,
-    plot_data,
-    plot_block,
-    plot_walkers_traj,
-)
+    plot_energy, plot_data, plot_block, plot_walkers_traj)
 import matplotlib.pyplot as plt
 import numpy as np
 
diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 9589dc8c..1c88fa72 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -4,13 +4,12 @@
 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"  ____    __  ______________             _")
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index f9aa3e11..73e3bb4f 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = "0.3.2"
+__version__ = '0.3.2'
diff --git a/qmctorch/sampler/__init__.py b/qmctorch/sampler/__init__.py
index 6a58bffc..8b135be4 100644
--- a/qmctorch/sampler/__init__.py
+++ b/qmctorch/sampler/__init__.py
@@ -1,11 +1,10 @@
 __all__ = [
-    "SamplerBase",
-    "Metropolis",
-    "Hamiltonian",
-    "PintsSampler",
-    "MetropolisHasting",
-    "GeneralizedMetropolis",
-]
+    'SamplerBase',
+    'Metropolis',
+    'Hamiltonian',
+    'PintsSampler',
+    'MetropolisHasting',
+    'GeneralizedMetropolis']
 
 from .sampler_base import SamplerBase
 from .metropolis import Metropolis
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index dbf9deef..3a2b53e7 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -9,18 +9,12 @@
 
 
 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__(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):
         """Generalized Metropolis Hasting sampler
 
         Args:
@@ -35,9 +29,9 @@ def __init__(
             cuda (bool, optional): use cuda. 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)
 
     def __call__(self, pdf, pos=None, with_tqdm=True):
         """Generate a series of point using MC sampling
@@ -52,6 +46,7 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
             torch.tensor: positions of the walkers
         """
         with torch.no_grad():
+
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
@@ -63,23 +58,22 @@ 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.0] = 1e-16
+                rhof[rhof == 0.] = 1E-16
 
                 # transtions
                 Tif = self.trans(xi, xf, driftf)
@@ -95,18 +89,17 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
                 # 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
 
@@ -124,12 +117,15 @@ def move(self, drift):
 
         # clone and reshape data : Nwlaker, Nelec, Ndim
         new_pos = self.walkers.pos.clone()
-        new_pos = new_pos.view(self.walkers.nwalkers, self.nelec, self.ndim)
+        new_pos = new_pos.view(self.walkers.nwalkers,
+                               self.nelec, self.ndim)
 
         # get indexes
-        index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
+        index = torch.LongTensor(self.walkers.nwalkers).random_(
+            0, self.nelec)
 
-        new_pos[range(self.walkers.nwalkers), index, :] += self._move(drift, index)
+        new_pos[range(self.walkers.nwalkers), index,
+                :] += self._move(drift, index)
 
         return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -144,16 +140,14 @@ def _move(self, drift, index):
             torch.tensor: position of the walkers
         """
 
-        d = drift.view(self.walkers.nwalkers, self.nelec, self.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)
-        )
+        mv = MultivariateNormal(torch.zeros(self.ndim), np.sqrt(
+            self.step_size) * torch.eye(self.ndim))
 
-        return (
-            self.step_size * d[range(self.walkers.nwalkers), index, :]
+        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
@@ -167,7 +161,7 @@ def trans(self, xf, xi, drifti):
             [type]: [description]
         """
         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):
         """Compute the drift velocity
@@ -180,10 +174,13 @@ 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):
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index ce592117..22496181 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -8,19 +8,18 @@
 
 
 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:
@@ -36,9 +35,9 @@ def __init__(
             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
@@ -100,19 +99,16 @@ 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
@@ -122,9 +118,8 @@ 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
@@ -148,7 +143,7 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = torch.randn(q.shape)
 
         # initial energy terms
-        E_init = U(q) + 0.5 * (p * p).sum(1)
+        E_init = U(q) + 0.5 * (p*p).sum(1)
 
         # half step in momentum space
         p -= 0.5 * epsilon * get_grad(U, q)
@@ -168,11 +163,11 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = -p
 
         # current energy term
-        E_new = U(q) + 0.5 * (p * p).sum(1)
+        E_new = U(q) + 0.5 * (p*p).sum(1)
 
         # 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
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 2fda5633..115b835d 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,20 +8,19 @@
 
 
 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"},
-        logspace: bool = False,
-        cuda: bool = False,
-    ):
+
+    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'},
+                 logspace: bool = False,
+                 cuda: bool = False):
         """Metropolis Hasting generator
 
         Args:
@@ -52,9 +51,9 @@ def __init__(
             >>> 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)
@@ -62,8 +61,9 @@ def __init__(
 
     def log_data(self):
         """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):
@@ -77,12 +77,8 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(
-        self,
-        pdf: Callable,
-        pos: Union[None, torch.Tensor] = None,
-        with_tqdm: bool = True,
-    ) -> torch.Tensor:
+    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:
@@ -97,14 +93,15 @@ def __call__(
 
         _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
 
@@ -117,15 +114,15 @@ def __call__(
             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)
 
@@ -136,36 +133,33 @@ def __call__(
                     else:
                         # new function
                         fxn = pdf(Xn)
-                        fxn[fxn == 0.0] = eps
+                        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 * 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)
-                )
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100))
+                log.info(
+                    "   Timing statistics   : {:1.2f} steps/sec.", self.nstep/(time()-tstart))
                 log.info(
-                    "   Timing statistics   : {:1.2f} steps/sec.",
-                    self.nstep / (time() - tstart),
-                )
-                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
+                    "   Total Time          : {:1.2f} sec.", (time()-tstart))
 
         return torch.cat(pos).requires_grad_()
 
@@ -188,30 +182,28 @@ 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.0)))
-            )
+        if self.movedict['proba'] == 'normal':
+            _sigma = self.step_size / \
+                (2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.))))
             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:
@@ -227,22 +219,27 @@ 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.walkers.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.walkers.nwalkers).random_(0, self.nelec)
+                index = torch.LongTensor(self.walkers.nwalkers).random_(
+                    0, self.nelec)
             else:
-                index = torch.LongTensor(self.walkers.nwalkers).fill_(id_elec)
+                index = torch.LongTensor(
+                    self.walkers.nwalkers).fill_(id_elec)
 
             # change selected data
-            new_pos[range(self.walkers.nwalkers), index, :] += self._move(1)
+            new_pos[range(self.walkers.nwalkers), index,
+                    :] += self._move(1)
 
             return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -255,17 +252,17 @@ 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.walkers.nwalkers, num_elec, self.ndim), device=self.device
-            ).view(self.walkers.nwalkers, num_elec * self.ndim)
-            return self.step_size * (2.0 * d - 1.0)
+                (self.walkers.nwalkers, num_elec, self.ndim), device=self.device).view(
+                self.walkers.nwalkers, num_elec * self.ndim)
+            return self.step_size * (2. * d - 1.)
 
-        elif self.movedict["proba"] == "normal":
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 9184ad7f..1a81e923 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -8,20 +8,19 @@
 
 
 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,
-    ):
+
+    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:
@@ -52,27 +51,26 @@ def __init__(
             >>> 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.movedict = move
 
-        if self.movedict["proba"] == "normal":
-            _sigma = self.step_size / (
-                2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.0)))
-            )
+        if self.movedict['proba'] == 'normal':
+            _sigma = self.step_size / \
+                (2 * torch.sqrt(2 * torch.log(torch.as_tensor(2.))))
             self.multiVariate = MultivariateNormal(
-                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim)
-            )
+                torch.zeros(self.ndim), _sigma * torch.eye(self.ndim))
 
         self.log_data()
 
     def log_data(self):
         """log data about the sampler."""
-        log.info("  Move type           : {0}", "all-elec")
-        log.info("  Move proba          : {0}", self.movedict["proba"])
+        log.info('  Move type           : {0}', 'all-elec')
+        log.info(
+            '  Move proba          : {0}', self.movedict['proba'])
 
     @staticmethod
     def log_func(func):
@@ -86,12 +84,8 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(
-        self,
-        pdf: Callable,
-        pos: Union[None, torch.Tensor] = None,
-        with_tqdm: bool = True,
-    ) -> torch.Tensor:
+    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:
@@ -111,9 +105,10 @@ def __call__(
         #     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
 
@@ -126,14 +121,13 @@ def __call__(
             # 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:
+
                 # new positions
                 Xn = self.move(pdf)
 
@@ -151,27 +145,26 @@ def __call__(
                 index = self._accept(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to("cpu") / (self.walkers.nwalkers)
+                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())
+                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)
-                )
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100))
+                log.info(
+                    "   Timing statistics   : {:1.2f} steps/sec.", self.nstep/(time()-tstart))
                 log.info(
-                    "   Timing statistics   : {:1.2f} steps/sec.",
-                    self.nstep / (time() - tstart),
-                )
-                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
+                    "   Total Time          : {:1.2f} sec.", (time()-tstart))
 
         return torch.cat(pos).requires_grad_()
 
@@ -196,17 +189,16 @@ 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.walkers.nwalkers, num_elec * self.ndim), device=self.device
-            )
-            return self.step_size * (2.0 * d - 1.0)
+                (self.walkers.nwalkers, num_elec*self.ndim), device=self.device)
+            return self.step_size * (2. * d - 1.)
 
-        elif self.movedict["proba"] == "normal":
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index b1473878..1934e877 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -10,19 +10,18 @@
 
 
 class MetropolisHasting(SamplerBase):
-    def __init__(
-        self,
-        kernel=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,
-    ):
+
+    def __init__(self,
+                 kernel=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):
         """Metropolis Hasting generator
 
         Args:
@@ -53,11 +52,12 @@ def __init__(
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(
-            self, nwalkers, nstep, 0.0, ntherm, ndecor, nelec, ndim, init, cuda
-        )
+        SamplerBase.__init__(self, nwalkers, nstep,
+                             0.0, ntherm, ndecor,
+                             nelec, ndim, init, cuda)
 
-        self.proposal = StateDependentNormalProposal(kernel, nelec, ndim, self.device)
+        self.proposal = StateDependentNormalProposal(
+            kernel, nelec, ndim, self.device)
 
         self.proposal.kernel.nelec = nelec
         self.proposal.kernel.ndim = ndim
@@ -82,12 +82,8 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(
-        self,
-        pdf: Callable,
-        pos: Union[None, torch.Tensor] = None,
-        with_tqdm: bool = True,
-    ) -> torch.Tensor:
+    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:
@@ -101,9 +97,10 @@ def __call__(
         """
 
         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
 
@@ -112,16 +109,16 @@ def __call__(
 
             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:
+
                 # new positions
-                Xn = self.walkers.pos + self.proposal(self.walkers.pos)
+                Xn = self.walkers.pos + \
+                    self.proposal(self.walkers.pos)
 
                 # new function
                 fxn = pdf(Xn)
@@ -130,7 +127,8 @@ def __call__(
                 prob_ratio = fxn / fx
 
                 # get transition ratio
-                trans_ratio = self.proposal.get_transition_ratio(self.walkers.pos, Xn)
+                trans_ratio = self.proposal.get_transition_ratio(
+                    self.walkers.pos, Xn)
 
                 # get the proba
                 df = prob_ratio * trans_ratio
@@ -139,26 +137,25 @@ def __call__(
                 index = self.accept_reject(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to("cpu") / (self.walkers.nwalkers)
+                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())
+                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)
-                )
+                    "   Acceptance rate     : {:1.2f} %", (rate / self.nstep * 100))
+                log.info(
+                    "   Timing statistics   : {:1.2f} steps/sec.", self.nstep/(time()-tstart))
                 log.info(
-                    "   Timing statistics   : {:1.2f} steps/sec.",
-                    self.nstep / (time() - tstart),
-                )
-                log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
+                    "   Total Time          : {:1.2f} sec.", (time()-tstart))
 
         return torch.cat(pos).requires_grad_()
 
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index a81c03be..fc923f8f 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -7,6 +7,7 @@
 
 
 class torch_model(pints.LogPDF):
+
     def __init__(self, pdf, ndim):
         """Ancillary class tha wrap the wave function in a PINTS class
 
@@ -43,7 +44,7 @@ def evaluateS1(self, x):
         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)
+        grad_log_pdf = 1./pdf * self.pdf(x, return_grad=True)
         return (log_pdf.cpu().detach().numpy(), grad_log_pdf.cpu().detach().numpy())
 
     def n_parameters(self):
@@ -52,21 +53,20 @@ def n_parameters(self):
 
 
 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,
-    ):
+
+    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:
@@ -97,9 +97,9 @@ def __init__(
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(
-            self, nwalkers, nstep, None, ntherm, ndecor, nelec, ndim, init, cuda
-        )
+        SamplerBase.__init__(self, nwalkers, nstep, None,
+                             ntherm, ndecor,
+                             nelec, ndim, init, cuda)
 
         self.method = method
         self.method_requires_grad = method_requires_grad
@@ -125,12 +125,8 @@ def log_func(func):
 
         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:
+    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:
@@ -144,13 +140,14 @@ def __call__(
         """
 
         if self.ntherm >= self.nstep:
-            raise ValueError("Thermalisation longer than trajectory")
+            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
 
@@ -158,16 +155,12 @@ def __call__(
             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,
-            )
+                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)
+        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
index eaa30c2e..fd96a120 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -8,7 +8,8 @@
 
 
 class DensityVarianceKernel(object):
-    def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
+
+    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
         self.atomic_pos = atomic_pos.unsqueeze(0).unsqueeze(1)
         self.sigma = sigma
         self.scale_factor = scale_factor
@@ -17,7 +18,7 @@ def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1.0 - d).sum(-1)
+        out = self.sigma * (1. - d).sum(-1)
         return out.unsqueeze(-1)
 
     def get_atomic_distance(self, pos):
@@ -28,12 +29,14 @@ def get_atomic_distance(self, pos):
 
     def get_estimate_density(self, pos):
         d = self.get_atomic_distance(pos)
-        d = torch.exp(-self.scale_factor * d**2)
+        d = torch.exp(-self.scale_factor*d**2)
         return d
 
 
 class CenterVarianceKernel(object):
-    def __init__(self, sigma=1.0, scale_factor=1.0):
+
+    def __init__(self, sigma=1., scale_factor=1.):
+
         self.sigma = sigma
         self.scale_factor = scale_factor
         self.nelec = None
@@ -41,14 +44,14 @@ def __init__(self, sigma=1.0, scale_factor=1.0):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1.0 - d)
+        out = self.sigma * (1. - 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)
+        d = torch.exp(-self.scale_factor*d**2)
         return d
 
 
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index f9dd33f6..b3be0870 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -5,9 +5,10 @@
 
 
 class SamplerBase:
-    def __init__(
-        self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
-    ):
+
+    def __init__(self, nwalkers, nstep, step_size,
+                 ntherm, ndecor, nelec, ndim, init,
+                 cuda):
         """Base class for the sampler
 
         Args:
@@ -31,35 +32,32 @@ def __init__(
         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.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"])
+        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, *args, **kwargs):
-        raise NotImplementedError("Sampler must have a __call__ method")
+        raise NotImplementedError(
+            "Sampler must have a __call__ method")
 
     def __repr__(self):
-        return (
-            self.__class__.__name__
-            + " sampler with  %d walkers" % self.walkers.nwalkers
-        )
+        return self.__class__.__name__ + ' sampler with  %d walkers' % self.walkers.nwalkers
 
     def get_sampling_size(self):
         """evaluate the number of sampling point we'll have."""
         if self.ntherm == -1:
             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
index b70a6a2b..941a9640 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -8,30 +8,34 @@
 
 
 class StateDependentNormalProposal(object):
+
     def __init__(self, kernel, nelec, ndim, device):
+
         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)
-        )
+            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
 
     def __call__(self, x):
         nwalkers = x.shape[0]
         scale = self.kernel(x)
-        displacement = self.multiVariate.sample((nwalkers, self.nelec)).to(self.device)
+        displacement = self.multiVariate.sample(
+            (nwalkers, self.nelec)).to(self.device)
         displacement *= scale
-        return displacement.view(nwalkers, self.nelec * self.ndim)
+        return displacement.view(nwalkers, self.nelec*self.ndim)
 
     def get_transition_ratio(self, x, y):
         sigmax = self.kernel(x)
         sigmay = self.kernel(y)
 
-        rdist = (x - y).view(-1, self.nelec, self.ndim).norm(dim=-1).unsqueeze(-1)
+        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))
+        prefac = (sigmax/sigmay)**(self.ndim/2)
+        tratio = torch.exp(-0.5*rdist**2 *
+                           (1./sigmay-1./sigmax))
         tratio *= prefac
 
         return tratio.squeeze().prod(-1)
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index c18411c2..4b88fd12 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -6,14 +6,9 @@
 
 
 class Walkers(object):
-    def __init__(
-        self,
-        nwalkers: int = 100,
-        nelec: int = 1,
-        ndim: int = 3,
-        init: Union[Dict, None] = None,
-        cuda: bool = False,
-    ):
+
+    def __init__(self, nwalkers: int = 100, nelec: int = 1, ndim: int = 3,
+                 init: Union[Dict, None] = None, cuda: bool = False):
         """Creates Walkers for the sampler.
 
         Args:
@@ -34,9 +29,9 @@ def __init__(
         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):
         """Initalize the position of the walkers
@@ -49,29 +44,29 @@ 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):
         """Initialize the walkers at the center of the molecule
@@ -79,9 +74,12 @@ def _init_center(self):
         Returns:
             torch.tensor: positions of the walkers
         """
-        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)
+        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):
         """Initialize the walkers in a box covering the molecule
@@ -90,9 +88,11 @@ def _init_uniform(self):
             torch.tensor: positions of the walkers
         """
         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
@@ -101,10 +101,10 @@ def _init_multivar(self):
             torch.tensor -- positions of the walkers
         """
         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']))
+        pos = multi.sample((self.nwalkers, self.nelec)).type(
+            torch.get_default_dtype())
         pos = pos.view(self.nwalkers, self.nelec * self.ndim)
         return pos.to(device=self.device)
 
@@ -118,26 +118,30 @@ def _init_atomic(self):
         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.0 / self.init_domain["atom_num"][_idx]
+                    s = 1. / self.init_domain['atom_num'][_idx]
                 elif nelec_placed[_idx] < 5:
-                    s = 2.0 / (self.init_domain["atom_num"][_idx] - 2)
+                    s = 2. / (self.init_domain['atom_num'][_idx] - 2)
                 else:
-                    s = 3.0 / (self.init_domain["atom_num"][_idx] - 3)
-                xyz[ielec, :] += np.random.normal(scale=s, size=(1, 3))
+                    s = 3. / (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 88ef7143..ee305cd7 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 052f89fb..e76d7587 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 a63d7f72..fbd91714 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -11,51 +11,40 @@
 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__(
-        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
-    ):
+
+    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
+
         CalculatorBase.__init__(
-            self,
-            atoms,
-            atom_coords,
-            basis,
-            charge,
-            spin,
-            scf,
-            units,
-            molname,
-            "adf",
-            savefile,
-        )
+            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'adf', savefile)
 
         # 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):
         """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()
@@ -85,8 +74,8 @@ def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
         bohr2angs = 0.529177
-        scale = 1.0
-        if self.units == "bohr":
+        scale = 1.
+        if self.units == 'bohr':
             scale = bohr2angs
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(scale * np.array(xyz))
@@ -97,32 +86,30 @@ def get_plams_settings(self):
         """Returns 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
@@ -141,46 +128,46 @@ def get_basis_data(self, kffile):
 
         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 = [], [], []
@@ -188,6 +175,7 @@ def get_basis_data(self, kffile):
         basis_bas_exp, basis_bas_norm = [], []
 
         for iat, at in enumerate(atom_type):
+
             number_copy = nqptr[iat + 1] - nqptr[iat]
             idx_bos = list(range(nbptr[iat] - 1, nbptr[iat + 1] - 1))
 
@@ -198,7 +186,8 @@ 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
@@ -214,10 +203,11 @@ 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
@@ -225,12 +215,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.0
+            perm_mat[npart[i], i] = 1.
 
         # reorder the basis function
         basis.mos = perm_mat @ mos
@@ -253,17 +243,17 @@ def read_array(kf, section, name):
         if data.shape == ():
             data = np.array([data])
         return data
-
-
+        
 class CalculatorADF2019(CalculatorADF):
+
     def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, savefile
-        )
+            self, atoms, atom_coords, basis, scf, units, molname, savefile)
 
-        self.adf_version = "adf2019"
-        self.job_name = "".join(self.atoms) + "_" + self.basis_name
-        self.output_file = self.job_name + ".t21"
+        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."""
@@ -279,20 +269,20 @@ def get_plams_settings(self):
         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
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index 007a69a0..6ae267ae 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -2,19 +2,8 @@
 
 
 class CalculatorBase:
-    def __init__(
-        self,
-        atoms,
-        atom_coords,
-        basis,
-        charge,
-        spin,
-        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
@@ -27,10 +16,12 @@ def __init__(
         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 06d75fe9..1e7904fa 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -8,22 +8,11 @@
 
 
 class CalculatorPySCF(CalculatorBase):
-    def __init__(
-        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
-    ):
+
+    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
+
         CalculatorBase.__init__(
-            self,
-            atoms,
-            atom_coords,
-            basis,
-            charge,
-            spin,
-            scf,
-            units,
-            molname,
-            "pyscf",
-            savefile,
-        )
+            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'pyscf', savefile)
 
     def run(self):
         """Run the scf calculation using PySCF."""
@@ -37,21 +26,20 @@ def run(self):
             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
 
@@ -67,7 +55,7 @@ def get_basis_data(self, mol, rhf):
         """
 
         # 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]}
@@ -76,8 +64,9 @@ 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
@@ -99,6 +88,7 @@ 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)
 
@@ -114,16 +104,17 @@ 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
@@ -169,16 +160,15 @@ 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)
@@ -206,21 +196,23 @@ def get_basis_data(self, mol, rhf):
         return basis
 
     def get_atoms_str(self):
-        """Refresh the atom string (use after atom move)."""
-        atoms_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"]
 
-        label2int = {"s": 1, "p": 2, "d": 3}
+        recognized_labels = ['s','p','d']
+
+        label2int = {'s': 1, 'p': 2, 'd': 3}
         labels = [l[:3] for l in mol.cart_labels(fmt=False)]
         unique_labels = []
         for l in labels:
@@ -229,13 +221,10 @@ 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 ba9a07d2..8160b6cf 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -13,32 +13,22 @@
 try:
     from mpi4py import MPI
 except ModuleNotFoundError:
-    log.info("  MPI not found.")
+    log.info('  MPI not found.')
 
 
 class Molecule:
-    def __init__(
-        self,
-        atom=None,
-        calculator="adf",
-        scf="hf",
-        basis="dzp",
-        unit="bohr",
-        charge=0,
-        spin=0,
-        name=None,
-        load=None,
-        save_scf_file=False,
-        redo_scf=False,
-        rank=0,
-        mpi_size=0,
-    ):
+
+    def __init__(self, atom=None, calculator='adf',
+                 scf='hf', basis='dzp', unit='bohr',
+                 charge=0, spin=0,
+                 name=None, load=None, save_scf_file=False,
+                 redo_scf=False, rank=0, mpi_size=0):
         """Create a molecule in QMCTorch
 
         Args:
             atom (str or None, optional): defines the atoms and their positions. Defaults to None.
                 - At1 x y z; At2 x y z ... : Provide the atomic coordinate directly
-                - <file>.xyz : provide the path to an .xyz file containing the atomic coordinates
+                - <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
@@ -85,88 +75,91 @@ def __init__(
         self.scf_level = 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.charge,
-                        self.spin,
-                        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()
 
             if mpi_size != 0:
+
                 MPI.COMM_WORLD.barrier()
 
                 if rank != 0:
-                    log.info("  Loading data from {file}", file=self.hdf5file)
+                    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)
-        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('  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 Energy          : {:.3f} Hartree".format(self.get_total_energy())
-        )
+            '  SCF Energy          : {:.3f} Hartree'.format(self.get_total_energy()))
 
     def domain(self, method):
         """Returns information to initialize the walkers
@@ -185,39 +178,42 @@ 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):
         """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)
 
@@ -232,14 +228,17 @@ 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":
+            if self.unit == 'angs':
                 conv2bohr = 1.8897259886
-            self.atom_coords.append([x * conv2bohr, y * conv2bohr, z * conv2bohr])
+            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
 
@@ -248,12 +247,11 @@ def _get_atomic_properties(self, atoms):
 
         # size of the system
         self.natom = len(self.atoms)
-        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)
+        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:
@@ -266,20 +264,20 @@ def _read_xyz_file(self):
         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 = ""
+        mol_name = ''
         unique_atoms = list(set(atoms))
         for ua in unique_atoms:
             mol_name += ua
@@ -291,46 +289,48 @@ def _get_mol_name(atoms):
     def _load_basis(self):
         """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
@@ -343,39 +343,31 @@ 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):
         """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):
         """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):
         """Load a molecule from hdf5
@@ -385,26 +377,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 865714fc..b53cb8c2 100644
--- a/qmctorch/solver/__init__.py
+++ b/qmctorch/solver/__init__.py
@@ -1,4 +1,5 @@
-__all__ = ["SolverBase", "Solver", "SolverMPI"]
+__all__ = ['SolverBase', 'Solver',
+           'SolverMPI']
 
 from .solver_base import SolverBase
 from .solver import Solver
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 11818411..94363fbb 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -2,16 +2,18 @@
 from time import time
 
 import torch
-from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
+from qmctorch.utils import (Loss,
+                            OrthoReg, add_group_attr,
+                            dump_to_hdf5, DataLoader)
 
 from .. import log
 from .solver_base import SolverBase
 
 
 class Solver(SolverBase):
-    def __init__(
-        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
-    ):
+
+    def __init__(self, wf=None, sampler=None, optimizer=None,
+                 scheduler=None, output=None, rank=0):
         """Basic QMC solver
 
         Args:
@@ -22,30 +24,22 @@ def __init__(
             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=None, freeze=None,
+                  loss=None, grad=None,
+                  ortho_mo=None, clip_loss=False,
+                  resampling=None):
         """Configure the solver
 
         Args:
@@ -75,9 +69,8 @@ def configure(
         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:
@@ -86,7 +79,8 @@ def configure(
         # 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.use_weight = (
+                self.resampling_options.resample_every > 1)
 
         # orthogonalization penalty for the MO coeffs
         if ortho_mo is not None:
@@ -105,7 +99,7 @@ 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"):
+        if hasattr(self.wf, 'jastrow'):
             for param in self.wf.jastrow.parameters():
                 param.requires_grad = wf_params
 
@@ -123,32 +117,33 @@ 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
 
                 else:
-                    opt_freeze = ["ci", "mo", "ao", "jastrow"]
-                    raise ValueError("Valid arguments for freeze are :", opt_freeze)
+                    opt_freeze = ['ci', 'mo', 'ao', 'jastrow']
+                    raise ValueError(
+                        'Valid arguments for freeze are :', opt_freeze)
 
     def save_sampling_parameters(self, pos):
-        """save the sampling params."""
+        """ 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
 
-        if self.resampling_options.mode == "update":
+        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]
@@ -159,17 +154,9 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.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,
-    ):
+    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:
@@ -196,27 +183,31 @@ def geo_opt(
 
         # log data
         self.prepare_optimization(batchsize, None, tqdm)
-        self.log_data_opt(nepoch, "geometry optimization")
+        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.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.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.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
@@ -237,9 +228,8 @@ def geo_opt(
 
         return self.observable
 
-    def run(
-        self, nepoch, batchsize=None, hdf5_group="wf_opt", chkpt_every=None, tqdm=False
-    ):
+    def run(self, nepoch, batchsize=None,
+            hdf5_group='wf_opt', chkpt_every=None, tqdm=False):
         """Run a wave function optimization
 
         Args:
@@ -255,7 +245,7 @@ def run(
 
         # 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)
@@ -287,7 +277,8 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         self.save_sampling_parameters(pos)
 
         # create the data loader
-        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
+        self.dataloader = DataLoader(
+            pos, batch_size=batchsize, pin_memory=self.cuda)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -303,9 +294,10 @@ 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):
         """Run a certain number of epochs
@@ -319,11 +311,11 @@ def run_epochs(self, nepoch):
 
         # loop over the epoch
         for n in range(nepoch):
+
             tstart = time()
-            log.info("")
-            log.info(
-                "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
-            )
+            log.info('')
+            log.info('  epoch %d | %d sampling points' %
+                     (n, len(self.dataloader.dataset)))
 
             cumulative_loss = 0
 
@@ -331,6 +323,7 @@ def run_epochs(self, nepoch):
 
             # loop over the batches
             for ibatch, data in enumerate(self.dataloader):
+
                 # port data to device
                 lpos = data.to(self.device)
 
@@ -340,11 +333,12 @@ 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
 
                 # 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)
@@ -352,7 +346,8 @@ def run_epochs(self, nepoch):
             # 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:
@@ -362,13 +357,14 @@ def run_epochs(self, nepoch):
             self.print_observable(cumulative_loss, verbose=False)
 
             # resample the data
-            self.dataloader.dataset = self.resample(n, self.dataloader.dataset)
+            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))
+            log.info('  epoch done in %1.2f sec.' % (time()-tstart))
 
         return cumulative_loss
 
@@ -409,26 +405,28 @@ 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 and wf values
             _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
             psi = self.wf(lpos)
-            norm = 1.0 / len(psi)
+            norm = 1. / len(psi)
 
             # evaluate the prefactor of the grads
             weight = eloc.clone()
             weight -= torch.mean(eloc)
             weight /= psi
-            weight *= 2.0
+            weight *= 2.
             weight *= norm
 
             # compute the gradients
@@ -437,22 +435,30 @@ def evaluate_grad_manual(self, lpos):
             return torch.mean(eloc), eloc
 
         else:
-            raise ValueError("Manual gradient only for energy minimization")
+            raise ValueError(
+                'Manual gradient only for energy minimization')
 
     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 ce5c1f41..497050c1 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -11,9 +11,10 @@
 
 
 class SolverBase:
-    def __init__(
-        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
-    ):
+
+    def __init__(self, wf=None, sampler=None,
+                 optimizer=None, scheduler=None,
+                 output=None, rank=0):
         """Base Class for QMC solver
 
         Args:
@@ -30,7 +31,7 @@ def __init__(
         self.opt = optimizer
         self.scheduler = scheduler
         self.cuda = False
-        self.device = torch.device("cpu")
+        self.device = torch.device('cpu')
 
         # member defined in the child and or method
         self.dataloader = None
@@ -38,38 +39,33 @@ def __init__(
         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 = '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
         if output is None:
-            basename = os.path.basename(self.wf.mol.hdf5file).split(".")[0]
-            self.hdf5file = basename + "_QMCTorch.hdf5"
+            basename = os.path.basename(
+                self.wf.mol.hdf5file).split('.')[0]
+            self.hdf5file = basename + '_QMCTorch.hdf5'
 
         if rank == 0:
             dump_to_hdf5(self, self.hdf5file)
 
         self.log_data()
 
-    def configure_resampling(
-        self,
-        mode="update",
-        resample_every=1,
-        nstep_update=25,
-        ntherm_update=-1,
-        increment={"every": None, "factor": None},
-    ):
+    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25, ntherm_update=-1,
+                             increment={'every': None, 'factor': None}):
         """Configure the resampling
 
         Args:
@@ -88,9 +84,10 @@ def configure_resampling(
         """
 
         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
@@ -111,47 +108,47 @@ 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()
 
         # 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()):
                     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()):
                     if p.requires_grad:
-                        self.observable.__setattr__(key + ".grad", [])
+                        self.observable.__setattr__(key+'.grad', [])
 
             else:
                 self.observable.__setattr__(k, [])
@@ -169,49 +166,50 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
             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":
+            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).item())
+                    self.observable.energy.append(
+                        np.mean(data).item())
                 else:
-                    self.observable.energy[-1] *= ibatch / (ibatch + 1)
-                    self.observable.energy[-1] += np.mean(data).item() / (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):
@@ -222,11 +220,12 @@ 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):
         """Print the observalbe to csreen
@@ -237,19 +236,23 @@ 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):
         """Resample the wave function
@@ -262,39 +265,39 @@ 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()[: self.sampler.walkers.nwalkers]).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
-                        )
+                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)
+                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, batchsize=None, hdf5_group="single_point"):
+    def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'):
         """Performs a single point calculatin
 
         Args:
@@ -306,22 +309,21 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
             SimpleNamespace: contains the local energy, positions, ...
         """
 
-        log.info("")
-        log.info(
-            "  Single Point Calculation : {nw} walkers | {ns} steps",
-            nw=self.sampler.walkers.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:
+
             #  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":
+            pos = 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
@@ -329,32 +331,40 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
                 eloc = self.wf.local_energy(pos)
 
             else:
-                nbatch = int(np.ceil(len(pos) / batchsize))
+                nbatch = int(np.ceil(len(pos)/batchsize))
 
                 for ibatch in range(nbatch):
                     istart = ibatch * batchsize
-                    iend = min((ibatch + 1) * batchsize, len(pos))
+                    iend = min((ibatch+1) * batchsize, len(pos))
                     if ibatch == 0:
-                        eloc = self.wf.local_energy(pos[istart:iend, :])
+                        eloc = self.wf.local_energy(
+                            pos[istart:iend, :])
                     else:
-                        eloc = torch.cat(
-                            (eloc, self.wf.local_energy(pos[istart:iend, :]))
-                        )
+                        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)
+            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())
 
             # dump data to hdf5
             obs = SimpleNamespace(
-                pos=pos, local_energy=eloc, 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
 
@@ -366,16 +376,13 @@ def save_checkpoint(self, epoch, loss):
             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,
-        )
+        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):
         """load a model/optmizer
@@ -387,10 +394,10 @@ 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):
@@ -405,7 +412,7 @@ 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=None, with_tqdm=True, hdf5_group='sampling_trajectory'):
         """Compute the local energy along a sampling trajectory
 
         Args:
@@ -415,8 +422,8 @@ 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)
@@ -424,15 +431,18 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group="sampling_trajector
         ndim = pos.shape[-1]
         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:
             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):
@@ -466,46 +476,52 @@ def save_traj(self, fname, obs):
         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, batchsize=None, loss='variance'):
         raise NotImplementedError()
 
     def log_data(self):
         """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 7562bc4d..fdf994c9 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -2,7 +2,8 @@
 from types import SimpleNamespace
 
 import torch
-from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
+from qmctorch.utils import (DataLoader, Loss, OrthoReg, add_group_attr,
+                            dump_to_hdf5)
 
 from .. import log
 from .solver import Solver
@@ -19,9 +20,9 @@ def logd(rank, *args):
 
 
 class SolverMPI(Solver):
-    def __init__(
-        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
-    ):
+
+    def __init__(self, wf=None, sampler=None, optimizer=None,
+                 scheduler=None, output=None, rank=0):
         """Distributed QMC solver
 
         Args:
@@ -33,26 +34,18 @@ def __init__(
             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.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(self, nepoch, batchsize=None, loss='energy',
+            clip_loss=False, grad='manual', hdf5_group='wf_opt',
+            num_threads=1, chkpt_every=None):
         """Run the optimization
 
         Args:
@@ -70,27 +63,21 @@ def run(
                                     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.walkers.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()
@@ -100,7 +87,8 @@ def run(
 
         # get the loss
         self.loss = Loss(self.wf, method=loss, clip=clip_loss)
-        self.loss.use_weight = self.resampling_options.resample_every > 1
+        self.loss.use_weight = (
+            self.resampling_options.resample_every > 1)
 
         # orthogonalization penalty for the MO coeffs
         self.ortho_loss = OrthoReg()
@@ -108,7 +96,7 @@ def run(
         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:
@@ -131,24 +119,27 @@ def run(
         _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]
 
         # create the data loader
         # self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
-        min_loss = 1e3
+        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.0
+            cumulative_loss = 0.
 
             for ibatch, data in enumerate(self.dataloader):
+
                 # get data
                 lpos = data.to(self.device)
                 lpos.requires_grad = True
@@ -162,13 +153,16 @@ def run(
 
                 # 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:
@@ -185,7 +179,8 @@ def run(
             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
@@ -194,11 +189,11 @@ def run(
 
         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=True, hdf5_group='single_point'):
         """Performs a single point calculation
 
         Args:
@@ -210,17 +205,13 @@ 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.walkers.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))
 
         # 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
@@ -229,39 +220,46 @@ 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":
+            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)
+            e, s, err = torch.mean(eloc), torch.var(
+                eloc), 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 = hvd.allgather(eloc, name='local_energies')
+            e, s, err = torch.mean(eloc_all), torch.var(
+                eloc_all), 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
+                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
 
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 10f8e555..67e0052b 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -1,14 +1,10 @@
 """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 .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,
@@ -16,44 +12,25 @@
 #                         plot_integrated_autocorrelation_time,
 #                         plot_walkers_traj)
 
-from .stat_utils import (
-    blocking,
-    correlation_coefficient,
-    integrated_autocorrelation_time,
-)
-from .torch_utils import (
-    DataSet,
-    DataLoader,
-    Loss,
-    OrthoReg,
-    fast_power,
-    set_torch_double_precision,
-    set_torch_single_precision,
-    diagonal_hessian,
-    gradients,
-)
+from .stat_utils import (blocking, correlation_coefficient,
+                         integrated_autocorrelation_time)
+from .torch_utils import (DataSet, DataLoader, Loss, OrthoReg, fast_power,
+                          set_torch_double_precision,
+                          set_torch_single_precision,
+                          diagonal_hessian, gradients)
 
 # __all__ = ['plot_energy', 'plot_data', 'plot_block',
 #            'plot_walkers_traj',
 #            'plot_correlation_time',
 #            'plot_autocorrelation',
-__all__ = [
-    "set_torch_double_precision",
-    "set_torch_single_precision",
-    "DataSet",
-    "Loss",
-    "OrthoReg",
-    "DataLoader",
-    "dump_to_hdf5",
-    "load_from_hdf5",
-    "bytes2str",
-    "register_extra_attributes",
-    "fast_power",
-    "InterpolateMolecularOrbitals",
-    "InterpolateAtomicOrbitals",
-    "btrace",
-    "bdet2",
-    "bproj",
-    "diagonal_hessian",
-    "gradients",
-]
+__all__ = ['set_torch_double_precision',
+           'set_torch_single_precision',
+           'DataSet', 'Loss', 'OrthoReg', 'DataLoader',
+           'dump_to_hdf5', 'load_from_hdf5',
+           'bytes2str',
+           'register_extra_attributes',
+           'fast_power',
+           'InterpolateMolecularOrbitals',
+           'InterpolateAtomicOrbitals',
+           'btrace', 'bdet2', 'bproj',
+           'diagonal_hessian', 'gradients']
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index a87c7be6..50f5d5bf 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -44,34 +44,33 @@ def bdet2(M):
 
 
 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)
 
         # 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/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 4ce2dc54..cff485a3 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -9,19 +9,16 @@
 
 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):
@@ -33,7 +30,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)
@@ -50,6 +47,7 @@ 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:
@@ -66,8 +64,12 @@ 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)
+            parent_obj.__setattr__(
+                grp_name, SimpleNamespace())
+        load_object(grp,
+                    parent_obj.__getattribute__(
+                        grp_name),
+                    grp_name)
     except:
         print_load_error(grp_name)
 
@@ -81,7 +83,8 @@ 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)
 
@@ -100,17 +103,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):
@@ -137,22 +140,23 @@ 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()
@@ -185,38 +189,35 @@ 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):
@@ -228,19 +229,17 @@ 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:
@@ -263,7 +262,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)
 
@@ -292,15 +291,16 @@ 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)
 
@@ -314,7 +314,8 @@ def insert_tuple(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
     # fix for type torch.Tensor
-    obj = [o.numpy() if isinstance(o, torch.Tensor) else o for o in obj]
+    obj = [o.numpy() if isinstance(
+        o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 
@@ -326,8 +327,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)
 
 
@@ -377,7 +378,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):
@@ -390,10 +391,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()
 
 
@@ -407,16 +408,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))
@@ -433,21 +434,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)
 
@@ -464,7 +465,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()
@@ -477,6 +478,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 9f19d833..89495ca4 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -8,21 +8,22 @@
 # TO DO : Remove this features as they are never used anywhere
 #################################################################################
 
-
 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):
-        if method == "irreg":
-            n = kwargs["n"] if "n" in kwargs else 6
+    def __call__(self, pos, method='irreg', orb='occupied', **kwargs):
+
+        if method == 'irreg':
+            n = kwargs['n'] if 'n' in kwargs else 6
             return self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
 
-        elif method == "reg":
-            rstr, bstr = "resolution", "border_length"
+        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.0
+            blength = kwargs[bstr] if bstr in kwargs else 2.
             return self.interpolate_mo_reg_grid(pos, res, blength, orb)
 
     def get_mo_max_index(self, orb):
@@ -35,12 +36,14 @@ def get_mo_max_index(self, orb):
             ValueError: if orb not valid
         """
 
-        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.
@@ -54,25 +57,26 @@ def interpolate_mo_irreg_grid(self, pos, n, orb):
         """
         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):
                 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()
+                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,  res, blength, orb):
         """Interpolate the mo occupied in the configs.
 
         Args:
@@ -84,26 +88,29 @@ 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]
+                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
@@ -120,30 +127,22 @@ def __call__(self, pos, n=6, length=2):
             torch.tensor: Interpolated values
         """
 
-        if not hasattr(self, "interp_func"):
+        if not hasattr(self, 'interp_func'):
             t0 = time()
             self.get_interpolator()
-            print("___", time() - t0)
+            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))
 
@@ -158,42 +157,37 @@ def get_interpolator(self, n=6, length=2):
         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):
             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.0,
-            )
-            for i in range(self.wf.ao.norb)
-        ]
+        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.0):
+def get_boundaries(atomic_positions, border_length=2.):
     """Computes the boundaries of the structure
 
     Args:
@@ -219,8 +213,7 @@ def get_boundaries(atomic_positions, border_length=2.0):
 
     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
@@ -228,7 +221,7 @@ def get_boundaries(atomic_positions, border_length=2.0):
     return pmin, pmax
 
 
-def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.0):
+def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.):
     """Computes a regular grid points from the atomic positions
 
     Args:
@@ -240,8 +233,9 @@ def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.0):
         (np.ndarray, np.ndarray, mp.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])
@@ -263,13 +257,16 @@ def interpolator_reg_grid(func, x, y, z):
         callable: 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.0
-    )
+    return RegularGridInterpolator((x, y, z),
+                                   data,
+                                   method='linear',
+                                   bounds_error=False,
+                                   fill_value=0.)
 
 
 def interpolate_reg_grid(interpfunc, pos):
@@ -283,31 +280,32 @@ 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
+    return x//2*2 == x
 
 
 def logspace(n, length):
     """returns a 1d array of logspace between -length and +length."""
-    k = np.log(length + 1) / np.log(10)
+    k = np.log(length+1)/np.log(10)
     if is_even(n):
-        x = np.logspace(0.01, k, n // 2) - 1
+        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.0, k, n//2+1)-1
         return np.concatenate((-x[::-1], x[1:]))
 
 
-def get_log_grid(atomic_positions, n=6, length=2.0, border_length=2.0):
+def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
     """Computes a logarithmic grid
 
     Args:
@@ -320,11 +318,14 @@ def get_log_grid(atomic_positions, n=6, length=2.0, border_length=2.0):
         np.ndanrray: 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
@@ -346,7 +347,9 @@ def interpolator_irreg_grid(func, grid_pts):
         callable: interpolation function
     """
 
-    return LinearNDInterpolator(grid_pts, func(grid_pts), fill_value=0.0)
+    return LinearNDInterpolator(grid_pts,
+                                func(grid_pts),
+                                fill_value=0.)
 
 
 def interpolate_irreg_grid(interpfunc, pos):
@@ -360,5 +363,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
+    nbatch, nelec, ndim = pos.shape[0], pos.shape[1]//3, 3
     return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim)))
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 10f3b61a..18d70ec8 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -2,12 +2,9 @@
 import numpy as np
 from matplotlib import cm
 
-from .stat_utils import (
-    blocking,
-    correlation_coefficient,
-    fit_correlation_coefficient,
-    integrated_autocorrelation_time,
-)
+from .stat_utils import (blocking, correlation_coefficient,
+                         fit_correlation_coefficient,
+                         integrated_autocorrelation_time)
 
 
 def plot_energy(local_energy, e0=None, show_variance=False):
@@ -30,22 +27,21 @@ def plot_energy(local_energy, e0=None, show_variance=False):
     variance = np.array([np.var(e) 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, energy - variance, energy +
+                    variance, 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()
@@ -64,12 +60,12 @@ 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, walkers='mean'):
     """Plot the trajectory of all the individual walkers
 
     Args:
@@ -81,26 +77,28 @@ def plot_walkers_traj(eloc, walkers="mean"):
     celoc /= np.arange(1, nstep + 1)
 
     if walkers is not None:
-        if walkers == "all":
-            plt.plot(eloc, "o", alpha=max(1 / nwalkers, 1e-2), 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()
 
@@ -118,18 +116,18 @@ def plot_correlation_coefficient(eloc, size_max=100):
     """
 
     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()
 
@@ -154,9 +152,11 @@ 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,23 +164,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, block_size, walkers='mean'):
     """Plot the blocked energy values
 
     Args:
@@ -192,24 +192,24 @@ def plot_blocking_energy(eloc, block_size, walkers="mean"):
         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)
@@ -233,8 +233,8 @@ 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()
 
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 38f2e4bc..11c2dc3d 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -13,7 +13,7 @@ def blocking(x, block_size, expand=False):
     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:
@@ -33,7 +33,7 @@ def correlation_coefficient(x, norm=True):
     N = x.shape[0]
     xm = x - x.mean(0)
 
-    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1 :]
+    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1:]
 
     if norm:
         c /= c[0]
@@ -48,7 +48,7 @@ def integrated_autocorrelation_time(correlation_coeff, size_max):
         correlation_coeff (np.ndarray): coeff size Nsample,Nexp
         size_max (int): max size
     """
-    return 1.0 + 2.0 * np.cumsum(correlation_coeff[1:size_max], 0)
+    return 1. + 2. * np.cumsum(correlation_coeff[1:size_max], 0)
 
 
 def fit_correlation_coefficient(coeff):
@@ -68,7 +68,7 @@ def fit_exp(x, y):
         def func(x, tau):
             return np.exp(-x / tau)
 
-        popt, pcov = curve_fit(func, x, y, p0=(1.0))
+        popt, pcov = curve_fit(func, x, y, p0=(1.))
         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 4050eeff..b61c0d56 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -31,6 +31,7 @@ def fast_power(x, k, mask0=None, mask2=None):
     """
     kmax = 3
     if k.max() < kmax:
+
         out = x.clone()
 
         if mask0 is None:
@@ -71,7 +72,10 @@ def diagonal_hessian(out, inp, return_grads=False):
     """
     # 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()
@@ -81,9 +85,11 @@ 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]
 
@@ -95,6 +101,7 @@ def diagonal_hessian(out, inp, return_grads=False):
 
 
 class DataSet(Dataset):
+
     def __init__(self, data):
         """Creates a torch data set
 
@@ -123,7 +130,8 @@ def __getitem__(self, index):
         return self.data[index, :]
 
 
-class DataLoader:
+class DataLoader():
+
     def __init__(self, data, batch_size, pin_memory=False):
         """Simple DataLoader to replace toch data loader
 
@@ -139,7 +147,7 @@ def __init__(self, data, batch_size, pin_memory=False):
             self.dataset = data
 
         self.len = len(data)
-        self.nbatch = ceil(self.len / batch_size)
+        self.nbatch = ceil(self.len/batch_size)
         self.count = 0
         self.batch_size = batch_size
 
@@ -148,14 +156,13 @@ def __iter__(self):
         return self
 
     def __next__(self):
-        if self.count < self.nbatch - 1:
-            out = self.dataset[
-                self.count * self.batch_size : (self.count + 1) * self.batch_size
-            ]
+        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 :]
+        elif self.count == self.nbatch-1:
+            out = self.dataset[self.count*self.batch_size:]
             self.count += 1
             return out
         else:
@@ -163,7 +170,12 @@ def __next__(self):
 
 
 class Loss(nn.Module):
-    def __init__(self, wf, method="energy", clip=False):
+
+    def __init__(
+            self,
+            wf,
+            method='energy',
+            clip=False):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -193,10 +205,11 @@ def __init__(self, wf, method="energy", clip=False):
         self.clip_num_std = 5
 
         # select loss function
-        self.loss_fn = {"energy": torch.mean, "variance": torch.var}[method]
+        self.loss_fn = {'energy': torch.mean,
+                        'variance': torch.var}[method]
 
         # init values of the weights
-        self.weight = {"psi": None, "psi0": None}
+        self.weight = {'psi': None, 'psi0': None}
 
     def forward(self, pos, no_grad=False, deactivate_weight=False):
         """Computes the loss
@@ -214,6 +227,7 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
 
         # check if grads are requested
         with self.get_grad_mode(no_grad):
+
             # compute local eneergies
             local_energies = self.wf.local_energy(pos)
 
@@ -249,41 +263,47 @@ def get_clipping_mask(self, 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)
+            mask = (
+                local_energies < emax) & (
+                local_energies > emin)
         else:
-            mask = torch.ones_like(local_energies).type(torch.bool)
+            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
+            done at every step
         """
 
-        local_use_weight = self.use_weight * (not deactivate_weight)
+        local_use_weight = self.use_weight * \
+            (not deactivate_weight)
 
         if local_use_weight:
+
             # computes the weights
-            self.weight["psi"] = self.wf(pos)
+            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"])
+            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 = (self.weight['psi'] / self.weight['psi0'])**2
                 w /= w.sum()  # should we multiply by the number of elements ?
 
             return w
 
         else:
-            return 1.0
+            return 1.
 
 
 class OrthoReg(nn.Module):
-    """add a penalty to make matrice orthgonal."""
+    '''add a penalty to make matrice orthgonal.'''
 
     def __init__(self, alpha=0.1):
         """Add a penalty loss to keep the MO orthogonalized
@@ -296,4 +316,6 @@ def __init__(self, alpha=0.1):
 
     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]))
+        return self.alpha * \
+            torch.norm(W.mm(W.transpose(0, 1)) -
+                       torch.eye(W.shape[0]))
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 6078939e..6d4e27de 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,13 +1,11 @@
-__all__ = ["WaveFunction", "SlaterJastrow"]
+__all__ = ['WaveFunction', 'SlaterJastrow']
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-
-__all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
+__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterOrbitalDependentJastrow']
 
 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
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 70fd8ee3..90bac67e 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,9 +1,11 @@
+
 import torch
 from torch import nn
 from functools import reduce
 
 
 class CombineJastrow(nn.Module):
+
     def __init__(self, jastrow):
         """[summary]
 
@@ -51,67 +53,69 @@ 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:
@@ -121,15 +125,15 @@ def get_derivative_combined_values(jast_vals, djast_vals):
         if len(djast_vals) == 1:
             return djast_vals[0]
         else:
-            out = 0.0
+            out = 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:
@@ -140,22 +144,25 @@ def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
         if len(d2jast_vals) == 1:
             return d2jast_vals[0]
         else:
-            out = 0.0
+            out = 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)
+                out = out + reduce(lambda x, y: x*y, tmp)
+
+            for i in range(nterms-1):
+                for j in range(i+1, nterms):
 
-            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)
+                    out = out + \
+                        (2.*reduce(lambda x, y: x*y, tmp)).sum(1)
 
             return out
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 9c8a776a..3b6fbd3a 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -1,13 +1,12 @@
 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):
         """Computes the electron-electron distances
 
@@ -37,9 +36,9 @@ 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):
         """Compute the pairwise distance between the electrons
@@ -80,6 +79,7 @@ def forward(self, input, derivative=0):
                 return dist
 
         elif derivative == 1:
+
             der_dist = self.get_der_distance(input_, dist)
 
             if self.scale:
@@ -88,13 +88,15 @@ 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
 
@@ -111,11 +113,14 @@ 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_)
@@ -138,9 +143,11 @@ 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.0 / (dist + eps_)).unsqueeze(1)
+        invr = (1. / (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
@@ -161,13 +168,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.0 / (dist**3 + eps_)).unsqueeze(1)
+        eps_ = self.eps * \
+            torch.diag(dist.new_ones(
+                dist.shape[-1])).expand_as(dist)
+        invr3 = (1. / (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):
@@ -181,7 +191,8 @@ 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
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index bba5e66b..ea4a67f4 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,13 +1,12 @@
 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 ElectronNucleiDistance(nn.Module):
+
     def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
         """Computes the electron-nuclei distances
 
@@ -68,18 +67,21 @@ 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
 
@@ -99,8 +101,9 @@ def get_der_distance(self, pos, dist):
         Returns:
             [type]: [description]
         """
-        invr = (1.0 / dist).unsqueeze(-1)
-        diff_axis = (pos.unsqueeze(-1) - self.atoms.T).transpose(2, 3)
+        invr = (1. / 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):
@@ -118,13 +121,14 @@ def get_second_der_distance(self, pos, dist):
         Returns:
             [type]: [description]
         """
-        invr3 = (1.0 / (dist**3)).unsqueeze(1)
+        invr3 = (1. / (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):
@@ -138,5 +142,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 070b6f32..216f5c79 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -16,7 +16,7 @@ def get_scaled_distance(kappa, r):
         torch.tensor: values of the scaled distance
                         Nbatch, Nelec, Nelec
     """
-    return (1.0 - torch.exp(-kappa * r)) / kappa
+    return (1. - torch.exp(-kappa * r))/kappa
 
 
 def get_der_scaled_distance(kappa, r, dr):
@@ -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 98540879..3c165029 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -1,6 +1,4 @@
-from .jastrow_factor_electron_electron import (
-    JastrowFactorElectronElectron as JastrowFactor,
-)
+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
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 d88d7f1a..6b121115 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -5,17 +5,14 @@
 
 
 class JastrowFactorElectronElectron(nn.Module):
-    def __init__(
-        self,
-        mol,
-        jastrow_kernel,
-        kernel_kwargs={},
-        orbital_dependent_kernel=False,
-        number_of_orbitals=None,
-        scale=False,
-        scale_factor=0.6,
-        cuda=False,
-    ):
+
+    def __init__(self, mol,
+                 jastrow_kernel,
+                 kernel_kwargs={},
+                 orbital_dependent_kernel=False,
+                 number_of_orbitals=None,
+                 scale=False, scale_factor=0.6,
+                 cuda=False):
         """Electron-Electron Jastrow factor.
 
         .. math::
@@ -41,35 +38,28 @@ def __init__(
         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:
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
-                mol.nup,
-                mol.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(
-                mol.nup, mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -81,10 +71,11 @@ def get_mask_tri_up(self):
         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
@@ -121,15 +112,13 @@ 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
-            )
+            return self.extract_tri_up(self.edist(
+                pos, derivative=2)).view(nbatch, 3, -1)
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -167,20 +156,21 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -198,7 +188,9 @@ 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
@@ -208,7 +200,9 @@ 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
@@ -234,7 +228,8 @@ 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]
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 b9407339..f2b5d55d 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
@@ -5,16 +5,11 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronBase):
-    def __init__(
-        self,
-        nup,
-        ndown,
-        cuda,
-        size1=16,
-        size2=8,
-        activation=torch.nn.Sigmoid(),
-        include_cusp_weight=True,
-    ):
+
+    def __init__(self,  nup, ndown, cuda,
+                 size1=16, size2=8,
+                 activation=torch.nn.Sigmoid(),
+                 include_cusp_weight=True):
         """Defines a fully connected jastrow factors."""
 
         super().__init__(nup, ndown, cuda)
@@ -25,13 +20,13 @@ def __init__(
         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)
 
@@ -46,12 +41,13 @@ def get_var_weight(self):
 
         nelec = self.nup + self.ndown
 
-        self.var_cusp_weight = nn.Parameter(torch.as_tensor([0.0, 0.0]))
+        self.var_cusp_weight = nn.Parameter(
+            torch.as_tensor([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:
@@ -67,29 +63,16 @@ def get_static_weight(self):
             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
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 7203719d..e0d032af 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
@@ -5,6 +5,7 @@
 
 
 class JastrowKernelElectronElectronBase(nn.Module):
+
     def __init__(self, nup, ndown, cuda, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
 
@@ -17,9 +18,9 @@ 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
 
@@ -70,6 +71,7 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
+
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -99,10 +101,12 @@ 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
 
@@ -130,7 +134,10 @@ 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 eddeeffd..3d1f4a99 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
@@ -6,7 +6,8 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronElectronBase):
-    def __init__(self, nup, ndown, cuda, w=1.0):
+
+    def __init__(self, nup, ndown, cuda, w=1.):
         """Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -25,8 +26,9 @@ def __init__(self, nup, ndown, cuda, w=1.0):
 
         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
@@ -38,35 +40,22 @@ def get_static_weight(self):
             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.
+        """ Get the jastrow kernel.
 
         .. math::
             B_{ij} = \\frac{w_0 r_{i,j}}{1+w r_{i,j}}
@@ -110,11 +99,11 @@ def compute_derivative(self, r, dr):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1.0 / (1.0 + self.weight * r_)
+        denom = 1. / (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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -139,7 +128,7 @@ def compute_second_derivative(self, r, dr, d2r):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1.0 / (1.0 + self.weight * r_)
+        denom = 1. / (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 e3f8bb93..f67c975c 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
@@ -6,7 +6,11 @@
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-    def __init__(self, nup, ndown, cuda, order=2, weight_a=None, weight_b=None):
+
+    def __init__(self, nup, ndown, cuda,
+                 order=2,
+                 weight_a=None,
+                 weight_b=None):
         """Computes a polynomial Pade-Jastrow factor
 
         .. math::
@@ -47,29 +51,16 @@ def get_static_weight(self):
             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
@@ -84,7 +75,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
@@ -97,13 +88,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.0
+            self.weight_b.data[0] = 1.
 
-        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.
+        """ Get the jastrow kernel.
 
         .. math::
 
@@ -200,13 +191,12 @@ 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
 
@@ -223,7 +213,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):
@@ -255,6 +245,7 @@ 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
@@ -286,9 +277,10 @@ def _compute_polynom_second_derivative(self, r, dr, d2r):
 
         r_ = r.unsqueeze(1)
         rnm1 = r.unsqueeze(1)
-        rnm2 = 1.0
+        rnm2 = 1.
 
         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 15d0dc21..f51e9f5e 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/orbital_dependent_jastrow_kernel.py
@@ -1,13 +1,14 @@
+
 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:
@@ -22,11 +23,10 @@ def __init__(self, nup, ndown, nmo, cuda, jastrow_kernel, kernel_kwargs={}):
         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,7 +66,9 @@ 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
@@ -105,11 +107,14 @@ 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)
 
@@ -150,8 +155,11 @@ 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 8c4b6053..bbb814b9 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -1,5 +1,3 @@
-from .jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei as JastrowFactor,
-)
+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
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 3d296aa5..2a5482bd 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
@@ -8,7 +8,11 @@
 
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
+
+    def __init__(self, mol,
+                 jastrow_kernel,
+                 kernel_kwargs={},
+                 cuda=False):
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -30,9 +34,9 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         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)
@@ -40,20 +44,24 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(
-            mol.nup, mol.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
@@ -69,10 +77,11 @@ def get_mask_tri_up(self):
         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
@@ -112,7 +121,8 @@ 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):
         """Assemle the different distances for easy calculations
@@ -167,9 +177,9 @@ def assemble_dist_deriv(self, pos, derivative=1):
     def _to_device(self):
         """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)
@@ -211,10 +221,9 @@ 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)
@@ -223,21 +232,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):
         """Compute the value of the derivative of the Jastrow factor
@@ -253,6 +264,7 @@ 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)
@@ -277,6 +289,7 @@ 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)
@@ -284,7 +297,8 @@ 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]
@@ -316,7 +330,8 @@ 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])
@@ -360,7 +375,7 @@ 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):
         """Compute the second derivative of the jastrow factor automatically.
@@ -372,24 +387,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 7810c835..ed68119e 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -1,5 +1,3 @@
 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
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 96111e7d..caa8b797 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,11 +1,10 @@
 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.
 
@@ -61,13 +60,15 @@ 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.0 + 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. + 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 ad0ed97c..adb44a07 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,10 +1,9 @@
 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, ndown, atomic_pos, cuda):
         """Defines a fully connected jastrow factors."""
 
@@ -18,9 +17,9 @@ 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()
 
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 b2042712..9fc3416b 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,6 +5,7 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
+
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base Class for the elec-elec-nuc jastrow kernel
 
@@ -25,9 +26,9 @@ 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):
@@ -57,14 +58,16 @@ def compute_derivative(self, r, dr):
         return out
 
     def compute_second_derivative(self, r, dr, d2r):
-        """Get the elements of the pure 2nd derivative of the jastrow kernels."""
+        """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
 
@@ -89,19 +92,20 @@ def _hess(val, pos, device):
             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/jastrow_factor_electron_nuclei.py b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
index b376d6ad..1bae2032 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -4,7 +4,11 @@
 
 
 class JastrowFactorElectronNuclei(nn.Module):
-    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
+
+    def __init__(self, mol,
+                 jastrow_kernel,
+                 kernel_kwargs={},
+                 cuda=False):
         r"""Base class for two el-nuc jastrow of the form:
 
         .. math::
@@ -24,9 +28,9 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         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)
@@ -34,15 +38,16 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(
-            mol.nup, mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -84,20 +89,21 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -113,10 +119,14 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
         """
         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):
@@ -134,11 +144,12 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
         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/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
index d9e5bd69..beefdc28 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,7 +5,8 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
+
+    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
         r"""Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -30,7 +31,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
         self.requires_autograd = True
 
     def forward(self, x):
-        """Get the jastrow kernel.
+        """ 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 d0890f3e..9d0050e0 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
@@ -4,6 +4,7 @@
 
 
 class JastrowKernelElectronNucleiBase(nn.Module):
+
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base class for the elec-nuc jastrow factor
 
@@ -26,9 +27,9 @@ 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):
@@ -72,6 +73,7 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
+
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -106,11 +108,13 @@ 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
 
@@ -138,7 +142,10 @@ 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 ca0b4159..501b0ae5 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
@@ -6,7 +6,8 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
+
+    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
         r"""Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -23,16 +24,15 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
 
         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.0]).to(self.device)
+        self.static_weight = torch.as_tensor([1.]).to(self.device)
         self.requires_autograd = True
 
     def forward(self, r):
-        """Get the jastrow kernel.
+        """ Get the jastrow kernel.
         .. math::
             B_{ij} = \frac{b r_{i,j}}{1+b'r_{i,j}}
 
@@ -70,11 +70,11 @@ def compute_derivative(self, r, dr):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1.0 / (1.0 + self.weight * r_)
+        denom = 1. / (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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -100,13 +100,13 @@ def compute_second_derivative(self, r, dr, d2r):
         """
 
         r_ = r.unsqueeze(1)
-        denom = 1.0 / (1.0 + self.weight * r_)
+        denom = 1. / (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/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 35a8f7f9..88be8258 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -19,10 +19,11 @@ def ElecElecGraph(nelec, nup):
 
 
 def get_elec_elec_edges(nelec):
-    """Compute the edge index of the electron-electron graph."""
+    """Compute the edge index of the electron-electron graph.
+    """
     ee_edges = ([], [])
-    for i in range(nelec - 1):
-        for j in range(i + 1, nelec):
+    for i in range(nelec-1):
+        for j in range(i+1, nelec):
             ee_edges[0].append(i)
             ee_edges[1].append(j)
 
@@ -33,7 +34,8 @@ def get_elec_elec_edges(nelec):
 
 
 def get_elec_elec_ndata(nelec, nup):
-    """Compute the node data of the elec-elec graph"""
+    """Compute the node data of the elec-elec graph
+    """
 
     ee_ndata = []
     for i in range(nelec):
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 0cb22dc8..0d6f0f72 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -16,20 +16,21 @@ def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
     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
-    )
+        natoms, atom_types, atomic_features, nelec, nup)
     return graph
 
 
 def get_elec_nuc_edges(natoms, nelec):
-    """Compute the edge index of the electron-nuclei graph."""
+    """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[1].append(natoms+j)
 
-            en_edges[0].append(natoms + j)
+            en_edges[0].append(natoms+j)
             en_edges[1].append(i)
 
     # for i in range(natoms-1):
@@ -39,8 +40,9 @@ def get_elec_nuc_edges(natoms, nelec):
     return en_edges
 
 
-def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
-    """Compute the node data of the elec-elec graph"""
+def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
+    """Compute the node data of the elec-elec graph
+    """
 
     en_ndata = []
     embed_number = 0
@@ -63,20 +65,22 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
         if i < nup:
             en_ndata.append(embed_number)
         else:
-            en_ndata.append(embed_number + 1)
+            en_ndata.append(embed_number+1)
 
     return torch.LongTensor(en_ndata)
 
 
 def get_atomic_features(atom_type, atomic_features):
-    """Get the atomic features requested."""
+    """Get the atomic features requested.
+    """
     if atom_type is not None:
         data = element(atom_type)
-        feat = [getattr(data, feat) for feat in atomic_features]
+        feat = [getattr(data, feat)
+                for feat in atomic_features]
     else:
         feat = []
         for atf in atomic_features:
-            if atf == "atomic_number":
+            if atf == 'atomic_number':
                 feat.append(-1)
             else:
                 feat.append(0)
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index a2c409c1..e74a5a9d 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -11,16 +11,14 @@
 
 
 class JastrowFactorGraph(nn.Module):
-    def __init__(
-        self,
-        mol,
-        ee_model=MGCNPredictor,
-        ee_model_kwargs={},
-        en_model=MGCNPredictor,
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-    ):
+
+    def __init__(self, mol,
+                 ee_model=MGCNPredictor,
+                 ee_model_kwargs={},
+                 en_model=MGCNPredictor,
+                 en_model_kwargs={},
+                 atomic_features=["atomic_number"],
+                 cuda=False):
         """Graph Neural Network Jastrow Factor
 
         Args:
@@ -44,13 +42,14 @@ def __init__(
         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.atom_types = mol.atoms
         self.atomic_features = atomic_features
-        self.atoms = torch.as_tensor(mol.atom_coords).to(self.device)
+        self.atoms = torch.as_tensor(
+            mol.atom_coords).to(self.device)
         self.natoms = self.atoms.shape[0]
 
         self.requires_autograd = True
@@ -59,8 +58,10 @@ def __init__(
         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)
+        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
@@ -69,16 +70,15 @@ def __init__(
 
         # instantiate the en model
         en_model_kwargs["num_node_types"] = 2 + self.natoms
-        en_model_kwargs["num_edge_types"] = 2 * self.natoms
+        en_model_kwargs["num_edge_types"] = 2*self.natoms
         self.en_model = en_model(**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
-        )
+        self.en_graph = ElecNucGraph(self.natoms, self.atom_types,
+                                     self.atomic_features, self.nelec, self.nup)
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -105,8 +105,8 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -115,16 +115,22 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -136,9 +142,7 @@ def forward(self, pos, derivative=0, sum_grad=True):
             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
-            )
+            return self._get_hess_vals(pos, ee_kernel, en_kernel, sum_grad=sum_grad, return_all=True)
 
     def _get_val(self, ee_kernel, en_kernel):
         """Get the jastrow values.
@@ -162,19 +166,18 @@ def _get_grad_vals(self, pos, ee_kernel, en_kernel, sum_grad):
 
         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)
+        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, ee_kernel, en_kernel, sum_grad=False, return_all=False
-    ):
+    def _get_hess_vals(self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=False):
         """Get the hessian values
 
         Args:
@@ -189,13 +192,10 @@ def _get_hess_vals(
 
         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]
+        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)
@@ -203,19 +203,18 @@ def _get_hess_vals(
         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]
+            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)
+        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)
+            grad_val = grad_val.detach().reshape(
+                nbatch, self.nelec, 3).transpose(1, 2)
 
             if sum_grad:
                 grad_val = grad_val.sum(1)
@@ -231,10 +230,11 @@ def get_mask_tri_up(self):
         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
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
index 871927d6..018030bf 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -57,11 +57,11 @@ def get_edge_types(self, edges):
         dict
             Mapping 'type' to the computed edge types.
         """
-        node_type1 = edges.src["type"]
-        node_type2 = edges.dst["type"]
+        node_type1 = edges.src['type']
+        node_type2 = edges.dst['type']
         return {
-            "type": node_type1 * node_type2
-            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+            'type': node_type1 * node_type2 +
+            (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
         }
 
     def forward(self, g, node_types):
@@ -80,9 +80,9 @@ def forward(self, g, node_types):
             Edge representations.
         """
         g = g.local_var()
-        g.ndata["type"] = node_types
+        g.ndata['type'] = node_types
         g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata["type"])
+        return self.embed(g.edata['type'])
 
 
 class VEConv(nn.Module):
@@ -109,7 +109,7 @@ def __init__(self, dist_feats, feats, update_edge=True):
         self.update_dists = nn.Sequential(
             nn.Linear(dist_feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
+            nn.Linear(feats, feats)
         )
         if update_edge:
             self.update_edge_feats = nn.Linear(feats, feats)
@@ -151,11 +151,12 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
             edge_feats = self.update_edge_feats(edge_feats)
 
         g = g.local_var()
-        g.ndata.update({"hv": node_feats})
-        g.edata.update({"dist": expanded_dists, "he": edge_feats})
-        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
-        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
-        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
+        g.ndata.update({'hv': node_feats})
+        g.edata.update({'dist': expanded_dists, 'he': edge_feats})
+        g.update_all(fn.u_mul_e('hv', 'dist', 'm_0'),
+                     fn.sum('m_0', 'hv_0'))
+        g.update_all(fn.copy_e('he', 'm_1'), fn.sum('m_1', 'hv_1'))
+        node_feats = g.ndata.pop('hv_0') + g.ndata.pop('hv_1')
 
         return node_feats, edge_feats
 
@@ -184,10 +185,11 @@ def __init__(self, feats, dist_feats):
         self.project_out_node_feats = nn.Sequential(
             nn.Linear(feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
+            nn.Linear(feats, feats)
         )
         self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
+            nn.Linear(feats, feats),
+            nn.Softplus(beta=0.5, threshold=14)
         )
 
     def reset_parameters(self):
@@ -222,8 +224,7 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
         """
         new_node_feats = self.project_in_node_feats(node_feats)
         new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists
-        )
+            g, new_node_feats, edge_feats, expanded_dists)
         new_node_feats = self.project_out_node_feats(new_node_feats)
         node_feats = node_feats + new_node_feats
 
@@ -256,15 +257,8 @@ class MGCNGNN(nn.Module):
         Difference between two adjacent centers in RBF expansion. Default to 0.1.
     """
 
-    def __init__(
-        self,
-        feats=128,
-        n_layers=3,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=30.0,
-        gap=0.1,
-    ):
+    def __init__(self, feats=128, n_layers=3, num_node_types=100,
+                 num_edge_types=3000, cutoff=30., gap=0.1):
         super(MGCNGNN, self).__init__()
 
         self.node_embed = nn.Embedding(num_node_types, feats)
@@ -275,7 +269,8 @@ def __init__(
 
         self.gnn_layers = nn.ModuleList()
         for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
+            self.gnn_layers.append(MultiLevelInteraction(
+                feats, len(self.rbf.centers)))
 
     def reset_parameters(self):
         """Reinitialize model parameters."""
@@ -310,6 +305,7 @@ def forward(self, g, node_types, edge_dists):
 
         all_layer_node_feats = [node_feats]
         for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
+            node_feats, edge_feats = gnn(
+                g, node_feats, edge_feats, expanded_dists)
             all_layer_node_feats.append(node_feats)
         return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
index 9f710fd3..abaf7153 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -40,41 +40,26 @@ class MGCNPredictor(nn.Module):
         Size for hidden representations in the output MLP predictor. Default to 64.
     """
 
-    def __init__(
-        self,
-        feats=128,
-        n_layers=3,
-        classifier_hidden_feats=64,
-        n_tasks=1,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=5.0,
-        gap=1.0,
-        predictor_hidden_feats=64,
-    ):
+    def __init__(self, feats=128, n_layers=3, classifier_hidden_feats=64,
+                 n_tasks=1, num_node_types=100, num_edge_types=3000,
+                 cutoff=5.0, gap=1.0, predictor_hidden_feats=64):
         super(MGCNPredictor, self).__init__()
 
         if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print(
-                "classifier_hidden_feats is deprecated and will be removed in the future, "
-                "use predictor_hidden_feats instead"
-            )
+            print('classifier_hidden_feats is deprecated and will be removed in the future, '
+                  'use predictor_hidden_feats instead')
             predictor_hidden_feats = classifier_hidden_feats
 
-        self.gnn = MGCNGNN(
-            feats=feats,
-            n_layers=n_layers,
-            num_node_types=num_node_types,
-            num_edge_types=num_edge_types,
-            cutoff=cutoff,
-            gap=gap,
-        )
-        self.readout = MLPNodeReadout(
-            node_feats=(n_layers + 1) * feats,
-            hidden_feats=predictor_hidden_feats,
-            graph_feats=n_tasks,
-            activation=nn.Softplus(beta=1, threshold=20),
-        )
+        self.gnn = MGCNGNN(feats=feats,
+                           n_layers=n_layers,
+                           num_node_types=num_node_types,
+                           num_edge_types=num_edge_types,
+                           cutoff=cutoff,
+                           gap=gap)
+        self.readout = MLPNodeReadout(node_feats=(n_layers + 1) * feats,
+                                      hidden_feats=predictor_hidden_feats,
+                                      graph_feats=n_tasks,
+                                      activation=nn.Softplus(beta=1, threshold=20))
 
     def forward(self, g, node_types, edge_dists):
         """Graph-level regression/soft classification.
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index d2f69a2a..6db28ce9 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,34 +1,29 @@
+
 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,
-        mol,
-        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:
@@ -48,7 +43,7 @@ def __init__(
         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():
@@ -56,34 +51,35 @@ def __init__(
 
         self.requires_autograd = True
 
-        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
-                )
-            )
+        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)
 
     def __repr__(self):
         """representation of the jastrow factor"""
         out = []
-        for k in ["ee", "en", "een"]:
+        for k in ['ee', 'en', 'een']:
             if self.jastrow_kernel_dict[k] is not None:
-                out.append(k + " -> " + self.jastrow_kernel_dict[k].__name__)
+                out.append(k + " -> " +
+                           self.jastrow_kernel_dict[k].__name__)
 
         return " + ".join(out)
 
@@ -109,67 +105,69 @@ 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:
@@ -179,15 +177,15 @@ def get_derivative_combined_values(jast_vals, djast_vals):
         if len(djast_vals) == 1:
             return djast_vals[0]
         else:
-            out = 0.0
+            out = 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:
@@ -198,22 +196,25 @@ def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
         if len(d2jast_vals) == 1:
             return d2jast_vals[0]
         else:
-            out = 0.0
+            out = 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)
+                out = out + reduce(lambda x, y: x*y, tmp)
+
+            for i in range(nterms-1):
+                for j in range(i+1, nterms):
 
-            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)
+                    out = out + \
+                        (2.*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 99929c5d..c3383923 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -2,16 +2,13 @@
 from torch import nn
 
 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
 
 
 class AtomicOrbitals(nn.Module):
+
     def __init__(self, mol, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -29,9 +26,8 @@ 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
@@ -39,94 +35,85 @@ 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)
 
         self.cuda = cuda
-        self.device = torch.device("cpu")
+        self.device = torch.device('cpu')
         if self.cuda:
             self._to_device()
 
     def __repr__(self):
         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,
-        )
+        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):
         """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, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -174,10 +161,10 @@ def forward(
             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
@@ -187,10 +174,12 @@ def forward(
             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)
@@ -200,8 +189,7 @@ def forward(
 
         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
@@ -270,7 +258,9 @@ 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])
 
@@ -306,9 +296,10 @@ 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)
 
@@ -329,12 +320,12 @@ 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
@@ -370,11 +361,13 @@ 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):
@@ -392,7 +385,8 @@ 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.0 * (dR * dY).sum(3) + R * d2Y)
+        d2ao = self.norm_cst * \
+            (d2R * Y + 2. * (dR * dY).sum(3) + R * d2Y)
         if self.contract:
             d2ao = self._contract(d2ao)
         return d2ao
@@ -411,19 +405,13 @@ 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)
 
@@ -444,16 +432,13 @@ 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.0 * (dR * dY) + R.unsqueeze(-1) * d2Y)
-        )
+        bas = self.norm_cst.unsqueeze(-1) * self.bas_coeffs.unsqueeze(-1) * \
+            (d2R * Y.unsqueeze(-1) + 2. *
+             (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
@@ -473,16 +458,14 @@ 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)
 
@@ -505,25 +488,15 @@ def _off_diag_hessian_kernel(self, R, dR, d2R, d2mR, Y, dY, d2Y, d2mY):
 
         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
@@ -549,19 +522,19 @@ def _compute_all_ao_values(self, 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):
         """Computes the positions/distance bewteen elec/orb
@@ -580,10 +553,8 @@ 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):
         """Computes the positions/distance bewteen elec/atoms
@@ -599,10 +570,11 @@ 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
 
@@ -617,9 +589,9 @@ 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
 
@@ -646,5 +618,6 @@ 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 b1f124ad..d3a7dbd3 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -3,6 +3,7 @@
 
 
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
+
     def __init__(self, mol, backflow, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -15,9 +16,7 @@ def __init__(self, mol, backflow, cuda=False):
         dtype = torch.get_default_dtype()
         self.backflow_trans = backflow
 
-    def forward(
-        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
-    ):
+    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -69,10 +68,10 @@ def forward(
             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
@@ -82,10 +81,12 @@ def forward(
             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)
@@ -95,8 +96,7 @@ def forward(
 
         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
@@ -179,9 +179,7 @@ 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:
@@ -196,7 +194,8 @@ def _compute_diag_hessian_backflow_ao_values(
             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)
@@ -222,13 +221,14 @@ def _compute_diag_hessian_backflow_ao_values(
         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)
@@ -254,19 +254,13 @@ 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)
@@ -275,15 +269,16 @@ 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)
 
@@ -300,6 +295,7 @@ def _process_position(self, pos):
                                         (Nbatch, Nelec, Norb)
         """
         if self.backflow_trans.orbital_dependent:
+
             # get the elec-atom vectrors/distances
             xyz, r = self._elec_ao_dist(pos)
 
@@ -311,15 +307,14 @@ def _process_position(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),
-            )
+            return (xyz.repeat_interleave(self.nshells, dim=2),
+                    r.repeat_interleave(self.nshells, dim=2))
 
     def _elec_atom_dist(self, pos):
         """Computes the positions/distance bewteen elec/atoms
@@ -338,10 +333,11 @@ 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))
+        r = torch.sqrt((xyz*xyz).sum(3))
 
         return xyz, r
 
@@ -371,14 +367,15 @@ 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/atomic_orbitals_orbital_dependent_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
index 50320839..239bc732 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
@@ -1,12 +1,11 @@
 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
 
@@ -17,16 +16,12 @@ 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
-    ):
+        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::
@@ -69,10 +64,10 @@ def forward(
             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
@@ -82,10 +77,12 @@ def forward(
             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)
@@ -95,8 +92,7 @@ def forward(
 
         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
@@ -181,9 +177,7 @@ 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:
@@ -198,7 +192,8 @@ def _compute_diag_hessian_backflow_ao_values(
             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)
@@ -224,13 +219,14 @@ def _compute_diag_hessian_backflow_ao_values(
         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)
@@ -256,19 +252,13 @@ 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)
@@ -277,15 +267,16 @@ 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)
 
@@ -338,14 +329,15 @@ 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/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 79ed8cee..30d42d26 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -6,14 +6,8 @@
 
 
 class BackFlowTransformation(nn.Module):
-    def __init__(
-        self,
-        mol,
-        backflow_kernel,
-        backflow_kernel_kwargs={},
-        orbital_dependent=False,
-        cuda=False,
-    ):
+
+    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, orbital_dependent=False, cuda=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
@@ -29,19 +23,21 @@ def __init__(
 
         if self.orbital_dependent:
             self.backflow_kernel = OrbitalDependentBackFlowKernel(
-                backflow_kernel, backflow_kernel_kwargs, mol, cuda
-            )
+                backflow_kernel, backflow_kernel_kwargs, mol, cuda)
         else:
-            self.backflow_kernel = backflow_kernel(mol, cuda, **backflow_kernel_kwargs)
+            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")
+            self.device = torch.device('cuda')
 
     def forward(self, pos, derivative=0):
+
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -53,8 +49,7 @@ 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 _get_backflow(self, pos):
         """Computes the backflow transformation
@@ -89,18 +84,18 @@ 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):
         """Computes the orbital dependent backflow transformation
@@ -120,21 +115,20 @@ def _backflow_od(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 _get_backflow_derivative(self, pos):
         r"""Computes the derivative of the backflow transformation
@@ -193,9 +187,8 @@ 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)
@@ -211,18 +204,21 @@ 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)
@@ -264,11 +260,8 @@ def _backflow_derivative_od(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)
@@ -285,23 +278,26 @@ def _backflow_derivative_od(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
@@ -369,9 +365,8 @@ 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
@@ -399,16 +394,13 @@ 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
@@ -416,7 +408,8 @@ 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)
@@ -459,11 +452,8 @@ def _backflow_second_derivative_od(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
@@ -492,16 +482,13 @@ def _backflow_second_derivative_od(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
@@ -509,10 +496,12 @@ def _backflow_second_derivative_od(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/backflow/kernels/backflow_kernel_autodiff_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
index 1ffb230c..f4479acb 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -4,6 +4,7 @@
 
 
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
+
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -14,10 +15,11 @@ 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.0
-        self.fc.weight.data[0, 0] = 1.0
+        self.fc.weight.data *= 0.
+        self.fc.weight.data[0, 0] = 1.
 
-        self.weight = nn.Parameter(torch.as_tensor([1e-3]))
+        self.weight = nn.Parameter(
+            torch.as_tensor([1E-3]))
 
     def _backflow_kernel(self, ree):
         """Computes the kernel via autodiff
@@ -30,4 +32,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.0 / (ree + eye) - eye)
+        return self.weight * mask * (1./(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 a898b236..0d220c48 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -4,6 +4,7 @@
 
 
 class BackFlowKernelBase(nn.Module):
+
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -14,9 +15,9 @@ 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):
         """Computes the desired values of the kernel
@@ -38,7 +39,8 @@ 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):
         """Computes the kernel via autodiff
@@ -49,7 +51,8 @@ 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):
         """Computes the first derivative of the kernel via autodiff
@@ -81,6 +84,7 @@ 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)
 
@@ -109,7 +113,10 @@ def _hess(val, ree):
             pos ([type]): [description]
         """
 
-        gval = grad(val, ree, grad_outputs=torch.ones_like(val), create_graph=True)[0]
+        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]
 
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 196da707..3820d0e9 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -5,6 +5,7 @@
 
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
+
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -17,7 +18,7 @@ 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
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 1b562d13..18ce0a5a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -4,6 +4,7 @@
 
 
 class BackFlowKernelInverse(BackFlowKernelBase):
+
     def __init__(self, mol, cuda=False):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -17,7 +18,8 @@ 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([1E-3]))  # .to(self.device)
 
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
@@ -34,7 +36,7 @@ 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.0 / (ree + eye) - eye)
+        return self.weight * mask * (1./(ree+eye) - eye)
 
     def _backflow_kernel_derivative(self, ree):
         """Computes the derivative of the kernel function
@@ -50,8 +52,8 @@ def _backflow_kernel_derivative(self, ree):
         """
 
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
-        invree = 1.0 / (ree + eye) - eye
-        return -self.weight * invree * invree
+        invree = (1./(ree+eye) - eye)
+        return - self.weight * invree * invree
 
     def _backflow_kernel_second_derivative(self, ree):
         """Computes the derivative of the kernel function
@@ -67,5 +69,5 @@ def _backflow_kernel_second_derivative(self, ree):
         """
 
         eye = torch.eye(self.nelec, self.nelec).to(self.device)
-        invree = 1.0 / (ree + eye) - eye
+        invree = (1./(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 925dbd96..72842a9a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -4,6 +4,7 @@
 
 
 class BackFlowKernelPowerSum(BackFlowKernelBase):
+
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -14,8 +15,8 @@ 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.0
-        self.fc.weight.data[0, 0] = 1e-4
+        self.fc.weight.data *= 0.
+        self.fc.weight.data[0, 0] = 1E-4
 
     def _backflow_kernel(self, ree):
         """Computes the kernel via autodiff
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
index 5cbe7f5a..f090a2bd 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -4,13 +4,13 @@
 
 
 class BackFlowKernelSquare(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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 92f9eef9..84e28e02 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -3,6 +3,7 @@
 
 
 class OrbitalDependentBackFlowKernel(nn.Module):
+
     def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
         """Compute orbital dependent back flow kernel, i.e. the functions
         f(rij) where rij is the distance between electron i and j
@@ -17,16 +18,12 @@ 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
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index b216bc94..4fcec886 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -6,6 +6,7 @@
 
 
 class OrbitalDependentBackFlowTransformation(nn.Module):
+
     def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """Transform the electorn coordinates into backflow coordinates.
         see : Orbital-dependent backflow wave functions for real-space quantum Monte Carlo
@@ -20,16 +21,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")
+            self.device = torch.device('cuda')
 
     def forward(self, pos, derivative=0):
+
         if derivative == 0:
             return self._backflow(pos)
 
@@ -41,8 +42,7 @@ 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):
         """Computes the backflow transformation
@@ -62,21 +62,20 @@ 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):
         r"""Computes the derivative of the backflow transformation
@@ -109,11 +108,8 @@ 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)
@@ -130,23 +126,26 @@ 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
@@ -184,11 +183,8 @@ 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
@@ -217,16 +213,13 @@ 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
@@ -234,10 +227,12 @@ 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/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 8b7d5546..77ee6990 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -17,30 +17,34 @@ 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, bas_exp):
@@ -56,10 +60,9 @@ def norm_slater_spherical(bas_n, bas_exp):
     Returns:
         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([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)
 
 
 def norm_gaussian_spherical(bas_n, bas_exp):
@@ -78,14 +81,13 @@ def norm_gaussian_spherical(bas_n, bas_exp):
     from scipy.special import factorial2 as f2
 
     bas_n = torch.tensor(bas_n)
-    bas_n = bas_n + 1.0
-    exp1 = 0.25 * (2.0 * bas_n + 1.0)
+    bas_n = bas_n + 1.
+    exp1 = 0.25 * (2. * bas_n + 1.)
 
-    A = torch.tensor(bas_exp) ** exp1
-    B = 2 ** (2.0 * bas_n + 3.0 / 2)
-    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi**0.5).type(
-        torch.get_default_dtype()
-    )
+    A = torch.tensor(bas_exp)**exp1
+    B = 2**(2. * bas_n + 3. / 2)
+    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi **
+                        0.5).type(torch.get_default_dtype())
 
     return torch.sqrt(B / C) * A
 
@@ -106,25 +108,23 @@ def norm_slater_cartesian(a, b, c, n, exp):
     """
     from scipy.special import factorial2 as f2
 
-    lvals = a + b + c + n + 1.0
+    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([np.math.factorial(int(2 * i))
+                             for i in lvals]).type(torch.get_default_dtype())
 
-    prefact = 4 * np.pi * lfact / ((2 * exp) ** (2 * lvals + 1))
+    prefact = 4 * np.pi * lfact / ((2 * exp)**(2 * lvals + 1))
 
-    num = torch.as_tensor(
-        f2(2 * a.astype("int") - 1)
-        * f2(2 * b.astype("int") - 1)
-        * f2(2 * c.astype("int") - 1)
-    ).type(torch.get_default_dtype())
+    num = torch.as_tensor(f2(2 * a.astype('int') - 1) *
+                          f2(2 * b.astype('int') - 1) *
+                          f2(2 * c.astype('int') - 1)
+                          ).type(torch.get_default_dtype())
 
-    denom = torch.as_tensor(f2((2 * a + 2 * b + 2 * c + 1).astype("int"))).type(
-        torch.get_default_dtype()
-    )
+    denom = torch.as_tensor(
+        f2((2 * a + 2 * b + 2 * c + 1).astype('int')
+           )).type(torch.get_default_dtype())
 
-    return torch.sqrt(1.0 / (prefact * num / denom))
+    return torch.sqrt(1. / (prefact * num / denom))
 
 
 def norm_gaussian_cartesian(a, b, c, exp):
@@ -143,14 +143,14 @@ def norm_gaussian_cartesian(a, b, c, exp):
 
     from scipy.special import factorial2 as f2
 
-    pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
-    am1 = (2 * a - 1).astype("int")
-    x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
+    pref = torch.as_tensor((2 * exp / np.pi)**(0.75))
+    am1 = (2 * a - 1).astype('int')
+    x = (4 * exp)**(a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
 
-    bm1 = (2 * b - 1).astype("int")
-    y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
+    bm1 = (2 * b - 1).astype('int')
+    y = (4 * exp)**(b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
 
-    cm1 = (2 * c - 1).astype("int")
-    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
+    cm1 = (2 * c - 1).astype('int')
+    z = (4 * exp)**(c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
 
     return (pref * x * y * z).type(torch.get_default_dtype())
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index aa765cdd..e0070b9f 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -2,9 +2,8 @@
 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, bas_n, bas_exp, xyz=None,
+                  derivative=0, sum_grad=True, sum_hess=True):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -49,54 +48,48 @@ def _first_derivative_kernel():
             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"""
+        """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.0 / R)
+            lap_er = bexp_er * (bas_exp - 2. / 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.0 + (bas_n - 2).unsqueeze(-1) * xyz2)
+            lap_rn = nRnm2.unsqueeze(-1) * \
+                (1. + (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():
         """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.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)
+        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) \
             + rn.unsqueeze(-1) * lap_er
-        )
 
     # computes the basic quantities
     rn = fast_power(R, bas_n)
@@ -104,24 +97,21 @@ 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)
+        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,
-    )
+    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
-):
+def radial_gaussian(R, bas_n, bas_exp, xyz=None, derivative=[0],
+                    sum_grad=True, sum_hess=True):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -150,83 +140,76 @@ def _kernel():
         return rn * er
 
     def _first_derivative_kernel():
+
         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():
+
         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.0 + (bas_n - 2).unsqueeze(-1) * xyz2)
+            lap_rn = nRnm2.unsqueeze(-1) * \
+                (1. + (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():
         """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
+    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,
-    )
+    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
-):
+def radial_gaussian_pure(R, bas_n, bas_exp, xyz=None, derivative=[0],
+                         sum_grad=True, sum_hess=True):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -264,13 +247,12 @@ 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():
@@ -283,26 +265,23 @@ 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,
-    )
+    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
-):
+def radial_slater_pure(R, bas_n, bas_exp, xyz=None, derivative=0,
+                       sum_grad=True, sum_hess=True):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -339,14 +318,14 @@ def _first_derivative_kernel():
             return nabla_er
 
     def _second_derivative_kernel():
+
         if sum_hess:
-            return bexp_er * (bas_exp - 2.0 / R)
+            return bexp_er * (bas_exp - 2. / 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():
@@ -355,11 +334,8 @@ def _mixed_second_derivative_kernel():
 
         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.0 / R.unsqueeze(-1))
-        )
+        lap_er = (bexp_er/(xyz*xyz).sum(-1)).unsqueeze(-1) * mix_prod * (
+            bas_exp.unsqueeze(-1) + 1./R.unsqueeze(-1))
 
         return lap_er
 
@@ -369,24 +345,19 @@ 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, _kernel,
+                         _first_derivative_kernel,
+                         _second_derivative_kernel,
+                         _mixed_second_derivative_kernel):
     """Returns the data contained in derivative
 
     Args:
@@ -401,12 +372,10 @@ def return_required_data(
 
     # prepare the output/kernel
     output = []
-    fns = [
-        _kernel,
-        _first_derivative_kernel,
-        _second_derivative_kernel,
-        _mixed_second_derivative_kernel,
-    ]
+    fns = [_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 01127598..8bd67029 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -3,6 +3,7 @@
 
 
 class Harmonics:
+
     def __init__(self, type, **kwargs):
         """Compute spherical or cartesian harmonics and their derivatives
 
@@ -28,30 +29,35 @@ 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
 
@@ -76,27 +82,18 @@ def __call__(self, xyz, derivative=[0], sum_grad=True, sum_hess=True):
             torch.tensor -- Values or gradient of the spherical 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")
+            raise ValueError('Harmonics type should be cart or sph')
 
 
-def CartesianHarmonics(
-    xyz, k, mask0, mask2, derivative=[0], sum_grad=True, sum_hess=True
-):
+def CartesianHarmonics(xyz, k, mask0, mask2, derivative=[0],
+                       sum_grad=True, sum_hess=True):
     r"""Computes Real Cartesian Harmonics
 
     .. math::
@@ -122,7 +119,7 @@ def _kernel():
         return xyz_k.prod(-1)
 
     def _first_derivative_kernel():
-        km1 = k - 1
+        km1 = k-1
         km1[km1 < 0] = 0
 
         xyz_km1 = fast_power(xyz, km1)
@@ -146,9 +143,12 @@ 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
@@ -156,29 +156,30 @@ def _second_derivative_kernel():
             return torch.stack((d2x, d2y, d2z), dim=-1)
 
     def _mixed_second_derivative_kernel():
-        km1 = k - 1
+        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:
@@ -206,22 +207,23 @@ def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
     """
     if not sum_hess:
         raise NotImplementedError(
-            "SphericalHarmonics cannot return individual component of the laplacian"
-        )
+            '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)
 
 
@@ -246,39 +248,42 @@ 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
 
@@ -304,27 +309,28 @@ 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
 
 
@@ -368,7 +374,6 @@ def _lap_spherical_harmonics_l0(xyz):
     """
     return torch.zeros_like(xyz[..., 0])
 
-
 # =============== L1
 
 
@@ -402,7 +407,7 @@ def _nabla_spherical_harmonics_l1(xyz, m):
     r = torch.sqrt((xyz**2).sum(3))
     r3 = r**3
     c = 0.4886025119029199
-    return c * (1.0 / r - xyz[:, :, :, index[m]] * xyz.sum(3) / r3)
+    return c * (1. / r - xyz[:, :, :, index[m]] * xyz.sum(3) / r3)
 
 
 def _grad_spherical_harmonics_l1(xyz, m):
@@ -422,38 +427,22 @@ 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,
-            )
-        )
+        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):
@@ -470,8 +459,7 @@ 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
 
@@ -493,18 +481,16 @@ 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):
@@ -527,30 +513,17 @@ 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):
@@ -577,64 +550,39 @@ 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,
-            )
-        )
+        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):
@@ -659,20 +607,15 @@ 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 c89489b6..c0d3aa9e 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -2,7 +2,9 @@
 
 
 class OrbitalConfigurations:
+
     def __init__(self, mol):
+
         self.nup = mol.nup
         self.ndown = mol.ndown
         self.nelec = self.nup + self.ndown
@@ -27,22 +29,22 @@ def get_configs(self, configs):
         if isinstance(configs, torch.Tensor):
             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)
@@ -50,10 +52,10 @@ 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)')
             raise ValueError("Config error")
 
     def sanity_check(self, nelec, norb):
@@ -66,10 +68,12 @@ def sanity_check(self, nelec, norb):
 
         """
         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
@@ -99,21 +103,29 @@ def _get_single_config(self, nocc, nvirt):
         _gs_down = list(range(self.ndown))
         cup, cdown = [_gs_up], [_gs_down]
 
-        for iocc in range(self.nup - 1, self.nup - 1 - nocc[0], -1):
+        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)
+                _xt = self._create_excitation(
+                    _gs_up.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(cup, cdown, _xt, _gs_down)
+                cup, cdown = self._append_excitations(
+                    cup, cdown, _xt, _gs_down)
 
-        for iocc in range(self.ndown - 1, self.ndown - 1 - nocc[1], -1):
+        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)
+                _xt = self._create_excitation(
+                    _gs_down.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(cup, cdown, _gs_up, _xt)
+                cup, cdown = self._append_excitations(
+                    cup, cdown, _gs_up, _xt)
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
@@ -131,40 +143,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[0], -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], -1))
-        idx_vrt_down = list(range(self.ndown, self.ndown + nvirt[1], 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))
 
@@ -176,22 +196,23 @@ def _get_cas_config(self, nocc, nvirt, nelec):
             nvirt ([type]): number of virt orbitals in the CAS
         """
         from itertools import combinations, product
-
         if self.spin != 0:
             raise ValueError(
-                "CAS active space not possible with spin polarized calculation"
-            )
+                '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[0] - 1, self.nup + nvirt[0] - 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 = [], []
@@ -221,7 +242,7 @@ def _get_orb_number(self, nelec, norb):
             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])
+        nvirt = (norb - nocc[0], norb-nocc[1])
         return nocc, nvirt
 
     def _create_excitation(self, conf, iocc, ivirt):
@@ -295,6 +316,7 @@ def get_excitation(configs):
     """
     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()))
 
@@ -303,19 +325,11 @@ 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)
 
@@ -339,6 +353,7 @@ def get_unique_excitation(configs):
     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()))
 
@@ -346,15 +361,11 @@ 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)
@@ -363,6 +374,7 @@ 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)
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index a1c30ec1..5f1a3cae 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -2,6 +2,7 @@
 
 
 class OrbitalProjector:
+
     def __init__(self, configs, mol, cuda=False):
         """Project the MO matrix in Slater Matrices
 
@@ -16,9 +17,9 @@ 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")
+            self.device = torch.device('cuda')
 
     def get_projectors(self):
         """Get the projectors of the conf in the CI expansion
@@ -30,12 +31,14 @@ def get_projectors(self):
         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 ic, (cup, cdown) in enumerate(
+                zip(self.configs[0], self.configs[1])):
+
             for _id, imo in enumerate(cup):
-                Pup[ic][imo, _id] = 1.0
+                Pup[ic][imo, _id] = 1.
 
             for _id, imo in enumerate(cdown):
-                Pdown[ic][imo, _id] = 1.0
+                Pdown[ic][imo, _id] = 1.
 
         return Pup.unsqueeze(1).to(self.device), Pdown.unsqueeze(1).to(self.device)
 
@@ -48,23 +51,25 @@ def split_orbitals(self, mat):
         Returns:
             torch.tensor: all slater matrices
         """
-        if not hasattr(self, "Pup"):
+        if not hasattr(self, 'Pup'):
             self.Pup, self.Pdown = self.get_projectors()
 
         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)
+            out_up = mat[..., :self.nup, :] @ self.Pup.unsqueeze(1)
+            out_down = mat[..., self.nup:,
+                           :] @ self.Pdown.unsqueeze(1)
 
         else:
             # case for single operator
-            out_up = mat[..., : self.nup, :] @ self.Pup
-            out_down = mat[..., self.nup :, :] @ self.Pdown
+            out_up = mat[..., :self.nup, :] @ self.Pup
+            out_down = mat[..., self.nup:, :] @ self.Pdown
 
         return out_up, out_down
 
 
 class ExcitationMask:
+
     def __init__(self, unique_excitations, mol, max_orb, cuda=False):
         """Select the occupied MOs of Slater determinant using masks
 
@@ -83,16 +88,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):
         """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 = []
@@ -100,54 +105,56 @@ 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):
         """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 8ad51e01..3091d04c 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -32,8 +32,7 @@ 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
@@ -41,16 +40,14 @@ def __init__(self, config_method, configs, mol, cuda=False):
         self.nelec = self.nup + self.ndown
 
         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):
         """Computes the values of the determinats
@@ -61,7 +58,7 @@ def forward(self, input):
         Returns:
             torch.tensor: slater determinants
         """
-        if self.config_method.startswith("cas("):
+        if self.config_method.startswith('cas('):
             return self.det_explicit(input)
         else:
             return self.det_single_double(input)
@@ -102,13 +99,12 @@ def det_single_double(self, input):
         """
 
         # compute the determinant of the unique single excitation
-        det_unique_up, det_unique_down = self.det_unique_single_double(input)
+        det_unique_up, det_unique_down = self.det_unique_single_double(
+            input)
 
         # 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]]
-        )
+        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
@@ -117,10 +113,8 @@ def det_ground_state(self, input):
             input (torch.tensor): MO matrices nbatch x nelec x nmo
         """
 
-        return (
-            torch.det(input[:, : self.nup, : self.nup]),
-            torch.det(input[:, self.nup :, : self.ndown]),
-        )
+        return (torch.det(input[:, :self.nup, :self.nup]),
+                torch.det(input[:, self.nup:, :self.ndown]))
 
     def det_unique_single_double(self, input):
         """Computes the SD of single/double excitations
@@ -151,21 +145,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
@@ -173,7 +167,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
@@ -181,57 +175,62 @@ 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
 
@@ -249,17 +248,18 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
         """
 
         # 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"):
+        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('cas('):
             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:
@@ -280,18 +280,18 @@ def operator_ground_state(self, mo, bop, op_squared=False):
         """
 
         # occupied orbital matrix + det and inv on spin up
-        Aocc_up = mo[:, : self.nup, : self.nup]
+        Aocc_up = mo[:, :self.nup, :self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup :, : self.ndown]
+        Aocc_down = mo[:, self.nup:, :self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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
@@ -328,7 +328,7 @@ def operator_explicit(self, mo, bkin, op_squared=False):
         Bup, Bdown = self.orb_proj.split_orbitals(bkin)
 
         # check ifwe have 1 or multiple ops
-        multiple_op = Bup.ndim == 5
+        multiple_op = (Bup.ndim == 5)
 
         # inverse of MO matrices
         iAup = torch.inverse(Aup)
@@ -373,12 +373,11 @@ def operator_single_double(self, mo, bop, op_squared=False):
             torch.tensor: kinetic energy values
         """
 
-        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)
 
-        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):
         """Compute the operator value of the unique single/double conformation
@@ -391,33 +390,33 @@ def operator_unique_single_double(self, mo, bop, op_squared):
 
         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]
+        Aocc_up = mo[:, :self.nup, :self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup :, : self.ndown]
+        Aocc_down = mo[:, self.nup:, :self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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)
@@ -430,85 +429,73 @@ 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_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_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:
+
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             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
         # typically trace(ABAB)
         else:
+
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -522,56 +509,42 @@ 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
 
@@ -593,7 +566,7 @@ def op_single(baseterm, mat_exc, M, index, nbatch):
         """
 
         # compute the values of T
-        T = 1.0 / mat_exc.view(nbatch, -1)[:, index]
+        T = (1. / mat_exc.view(nbatch, -1)[:, index])
 
         # computes trace(T M)
         op_vals = T * M[..., index]
@@ -662,14 +635,14 @@ def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
         """
 
         # get the values of the inverse excitation matrix
-        T = 1.0 / (mat_exc.view(nbatch, -1)[:, index])
+        T = 1. / (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
@@ -718,7 +691,7 @@ 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
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 33fde499..358221f5 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,3 +1,5 @@
+
+
 import torch
 from scipy.optimize import curve_fit
 from copy import deepcopy
@@ -17,16 +19,14 @@
 
 
 class SlaterJastrow(WaveFunction):
-    def __init__(
-        self,
-        mol,
-        jastrow=None,
-        backflow=None,
-        configs="ground_state",
-        kinetic="jacobi",
-        cuda=False,
-        include_all_mo=True,
-    ):
+
+    def __init__(self, mol,
+                 jastrow=None,
+                 backflow=None,
+                 configs='ground_state',
+                 kinetic='jacobi',
+                 cuda=False,
+                 include_all_mo=True):
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
         .. math::
@@ -37,19 +37,19 @@ def __init__(
         .. 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_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels        
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation    
             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
             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
@@ -61,15 +61,16 @@ def __init__(
             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
 
-        super().__init__(mol.nelec, 3, kinetic, cuda)
+        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")
+            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")
+        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
@@ -101,7 +102,10 @@ def __init__(
         self.init_kinetic(kinetic, backflow)
 
         # register the callable for hdf5 dump
-        register_extra_attributes(self, ["ao", "mo_scf", "mo", "jastrow", "pool", "fc"])
+        register_extra_attributes(self,
+                                  ['ao', 'mo_scf',
+                                   'mo', 'jastrow',
+                                   'pool', 'fc'])
 
         self.log_data()
 
@@ -111,7 +115,8 @@ def init_atomic_orb(self, backflow):
         if self.backflow is None:
             self.ao = AtomicOrbitals(self.mol, self.cuda)
         else:
-            self.ao = AtomicOrbitalsBackFlow(self.mol, self.backflow, self.cuda)
+            self.ao = AtomicOrbitalsBackFlow(
+                self.mol, self.backflow, self.cuda)
 
         if self.cuda:
             self.ao = self.ao.to(self.device)
@@ -124,7 +129,8 @@ def init_molecular_orb(self, include_all_mo):
         self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
 
         # scf layer
-        self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
+        self.mo_scf = nn.Linear(
+            self.mol.basis.nao, self.nmo_opt, bias=False)
         self.mo_scf.weight = self.get_mo_coeffs()
         self.mo_scf.weight.requires_grad = False
 
@@ -139,7 +145,8 @@ def init_mo_mixer(self):
         self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
 
         # init the weight to idenity matrix
-        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
+        self.mo.weight = nn.Parameter(
+            torch.eye(self.nmo_opt, self.nmo_opt))
 
         # put on the card if needed
         if self.cuda:
@@ -153,15 +160,15 @@ def init_config(self, configs):
         self.configs_method = configs
         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
+        self.highest_occ_mo = max(
+            self.configs[0].max(), self.configs[1].max())+1
 
     def init_slater_det_calculator(self):
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(
-            self.configs_method, self.configs, self.mol, self.cuda
-        )
+        self.pool = SlaterPooling(self.configs_method,
+                                  self.configs, self.mol, self.cuda)
 
     def init_fc_layer(self):
         """Init the fc layer"""
@@ -170,8 +177,8 @@ def init_fc_layer(self):
         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
+        self.fc.weight.data.fill_(0.)
+        self.fc.weight.data[0][0] = 1.
 
         # port to card
         if self.cuda:
@@ -201,10 +208,10 @@ def set_combined_jastrow(self, jastrow):
         self.jastrow = CombineJastrow(jastrow)
 
     def init_kinetic(self, kinetic, backflow):
-        """ "Init the calculator of the kinetic energies"""
+        """"Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
-        if kinetic == "jacobi":
+        if kinetic == 'jacobi':
             if backflow is None:
                 self.kinetic_energy = self.kinetic_energy_jacobi
 
@@ -385,6 +392,7 @@ 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
@@ -397,10 +405,11 @@ 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
@@ -411,7 +420,7 @@ 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, ao, dao, d2ao,  mo):
         """Compute the Bkin matrix
 
         Args:
@@ -425,7 +434,10 @@ 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
@@ -439,7 +451,7 @@ def get_kinetic_operator(self, x, ao, dao, d2ao, mo):
 
         return -0.5 * bkin
 
-    def kinetic_energy_jacobi_backflow(self, x, **kwargs):
+    def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -473,7 +485,8 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(
+            x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -494,12 +507,10 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         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 = (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
 
@@ -507,7 +518,9 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -524,13 +537,15 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) * slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2*(grad_val * djast).sum(0) + \
+            hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -541,37 +556,42 @@ def gradients_jacobi_backflow(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            "Gradient through Jacobi formulat not implemented for backflow orbitals"
-        )
+            'Gradient through Jacobi formulat not implemented for backflow orbitals')
 
     def log_data(self):
         """Print information abut the wave function."""
-        log.info("")
-        log.info(" Wave Function")
-        log.info("  Jastrow factor      : {0}", self.use_jastrow)
+        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.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      : ")
+        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()])
+            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)
+        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))
+            log.info(
+                '  GPU                 : {0}', torch.cuda.get_device_name(0))
 
     def get_mo_coeffs(self):
         """Get the molecular orbital coefficients to init the mo layer."""
-        mo_coeff = torch.as_tensor(self.mol.basis.mos).type(torch.get_default_dtype())
+        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]
+            mo_coeff = mo_coeff[:, :self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -590,19 +610,20 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-            xyz = self.ao.atom_coords[iat, :].cpu().detach().numpy().tolist()
+            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
+            The SZ sto that have only one basis function per ao
         """
 
-        assert self.ao.radial_type.startswith("gto")
-        assert self.ao.harmonics_type == "cart"
+        assert(self.ao.radial_type.startswith('gto'))
+        assert(self.ao.harmonics_type == 'cart')
 
-        log.info("  Fit GTOs to STOs  : ")
+        log.info('  Fit GTOs to STOs  : ')
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -616,7 +637,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = "sto_pure"
+        basis.radial_type = 'sto_pure'
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -634,12 +655,14 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -650,20 +673,16 @@ def sto(x, norm, alpha):
             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()
-            )
+            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:
                 import matplotlib.pyplot as plt
-
                 plt.plot(xdata, ydata)
                 plt.plot(xdata, sto(xdata, *popt))
                 plt.show()
@@ -672,12 +691,8 @@ def sto(x, norm, alpha):
         new_mol.basis = basis
 
         # returns new orbital instance
-        return self.__class__(
-            new_mol,
-            self.jastrow,
-            backflow=self.backflow,
-            configs=self.configs_method,
-            kinetic=self.kinetic_method,
-            cuda=self.cuda,
-            include_all_mo=self.include_all_mo,
-        )
+        return self.__class__(new_mol, self.jastrow, backflow=self.backflow,
+                              configs=self.configs_method,
+                              kinetic=self.kinetic_method,
+                              cuda=self.cuda,
+                              include_all_mo=self.include_all_mo)
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index e1b5e2d4..15cec289 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -3,22 +3,18 @@
 
 from .slater_jastrow import SlaterJastrow
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import (
-    JastrowFactorElectronElectron,
-)
+from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        jastrow_kernel=PadeJastrowKernel,
-        jastrow_kernel_kwargs={},
-        cuda=False,
-        include_all_mo=True,
-    ):
+
+    def __init__(self, mol,
+                 configs='ground_state',
+                 kinetic='jacobi',
+                 jastrow_kernel=PadeJastrowKernel,
+                 jastrow_kernel_kwargs={},
+                 cuda=False,
+                 include_all_mo=True):
         """Slater Jastrow Wave function with an orbital dependent Electron-Electron Jastrow Factor
 
         .. math::
@@ -27,17 +23,17 @@ def __init__(
         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
@@ -53,8 +49,7 @@ def __init__(
 
         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, None, None, configs, kinetic, cuda, include_all_mo)
         self.use_jastrow = True
@@ -65,8 +60,7 @@ def __init__(
             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)
@@ -182,21 +176,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])
 
@@ -206,9 +200,10 @@ 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)
@@ -217,7 +212,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,  **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
@@ -252,12 +247,10 @@ 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)
@@ -271,8 +264,7 @@ 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)
@@ -311,7 +303,8 @@ 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
@@ -341,12 +334,12 @@ 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):
         """Compute the gradient operator
@@ -377,7 +370,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/trash/slater_combined_jastrow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
index b468f129..b308d190 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
@@ -1,31 +1,28 @@
+
+
 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.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 .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,
-    ):
+
+    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::
@@ -34,7 +31,7 @@ def __init__(
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)
+            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
 
@@ -42,13 +39,13 @@ def __init__(
             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 (dict, optional) : different Jastrow kernels for the different terms.
+            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.
@@ -65,23 +62,22 @@ def __init__(
 
         # process the Jastrow
         if jastrow_kernel is not None:
-            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():
                     jastrow_kernel_kwargs[k] = None
 
             self.use_jastrow = True
-            self.jastrow_type = "JastrowFactorCombinedTerms"
+            self.jastrow_type = 'JastrowFactorCombinedTerms'
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup,
-                self.mol.ndown,
+                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,
-            )
+                cuda=cuda)
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
diff --git a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
index e411e7c5..023ea286 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
@@ -1,43 +1,38 @@
+
+
 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.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 .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.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,
-    ):
+
+    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::
@@ -46,7 +41,7 @@ def __init__(
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)
+            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
 
@@ -61,23 +56,23 @@ def __init__(
             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 (dict, optional) : different Jastrow kernels for the different terms.
+            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.
+            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
+            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
@@ -90,35 +85,32 @@ def __init__(
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda
-            )
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda
-            )
+                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"]:
+
+            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_type = 'JastrowFactorCombinedTerms'
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup,
-                self.mol.ndown,
+                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,
-            )
+                cuda=cuda)
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
@@ -191,7 +183,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x, **kwargs):
+    def kinetic_energy_jacobi(self, x,  **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -225,7 +217,8 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(
+            x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -246,12 +239,10 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         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 = (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
 
@@ -259,7 +250,9 @@ def kinetic_energy_jacobi(self, x, **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -276,13 +269,15 @@ def kinetic_energy_jacobi(self, x, **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) * slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2*(grad_val * djast).sum(0) + \
+            hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -293,5 +288,4 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            "Gradient through Jacobi formulat not implemented for backflow orbitals"
-        )
+            'Gradient through Jacobi formulat not implemented for backflow orbitals')
diff --git a/qmctorch/wavefunction/trash/slater_jastrow.py b/qmctorch/wavefunction/trash/slater_jastrow.py
index 3cbae13c..81b84492 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow.py
@@ -1,24 +1,21 @@
+
+
 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 .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 
 
 class SlaterJastrow(SlaterJastrowBase):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        jastrow_kernel=PadeJastrowKernel,
-        jastrow_kernel_kwargs={},
-        cuda=False,
-        include_all_mo=True,
-    ):
+
+    def __init__(self, mol, configs='ground_state',
+                 kinetic='jacobi',
+                 jastrow_kernel=PadeJastrowKernel,
+                 jastrow_kernel_kwargs={},
+                 cuda=False,
+                 include_all_mo=True):
         """Implementation of the QMC Network.
 
         Args:
@@ -39,15 +36,12 @@ def __init__(
 
         # process the Jastrow
         if jastrow_kernel is not None:
+
             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,
-            )
+                self.mol.nup, self.mol.ndown, jastrow_kernel,
+                kernel_kwargs=jastrow_kernel_kwargs, cuda=cuda)
 
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
@@ -219,6 +213,7 @@ 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
@@ -231,10 +226,11 @@ 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
@@ -245,7 +241,7 @@ 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, ao, dao, d2ao,  mo):
         """Compute the Bkin matrix
 
         Args:
@@ -259,7 +255,10 @@ 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
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
index da7b6cdb..38690d0a 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
@@ -1,3 +1,5 @@
+
+
 import torch
 
 from torch import nn
@@ -6,31 +8,24 @@
 from .. import log
 
 from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from .orbitals.atomic_orbitals_orbital_dependent_backflow import (
-    AtomicOrbitalsOrbitalDependentBackFlow,
-)
+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,
-)
+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,
-    ):
+
+    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::
@@ -40,7 +35,7 @@ def __init__(
 
         .. math::
             J(r) = \\exp\\left( K_{ee}(r) \\right)
-
+        
         with K, a kernel function depending only on the electron-eletron distances, and
 
         .. math::
@@ -54,22 +49,22 @@ def __init__(
             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
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation.
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation. 
                 - By default an inverse kernel K(r_{ij}) = w/r_{ij} is used
             backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
-            orbital_dependent_backflow (bool, optional) : every orbital has a different transformation if True. Default to False
+            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
@@ -82,21 +77,15 @@ def __init__(
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda
-            )
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda
-            )
+                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,
-        )
+            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
@@ -173,7 +162,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x, **kwargs):
+    def kinetic_energy_jacobi(self, x,  **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -207,7 +196,8 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(
+            x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -228,12 +218,10 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         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 = (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
 
@@ -241,7 +229,9 @@ def kinetic_energy_jacobi(self, x, **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -258,13 +248,15 @@ def kinetic_energy_jacobi(self, x, **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) * slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2*(grad_val * djast).sum(0) + \
+            hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -275,5 +267,4 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            "Gradient through Jacobi formulat not implemented for backflow orbitals"
-        )
+            'Gradient through Jacobi formulat not implemented for backflow orbitals')
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_base.py b/qmctorch/wavefunction/trash/slater_jastrow_base.py
index 24a545eb..3214b488 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_base.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_base.py
@@ -16,40 +16,40 @@
 
 
 class SlaterJastrowBase(WaveFunction):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        cuda=False,
-        include_all_mo=True,
-    ):
+
+    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(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
             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)
+        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")
+            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")
+        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
@@ -61,7 +61,7 @@ def __init__(
         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
+        self.highest_occ_mo = torch.stack(self.configs).max()+1
 
         # define the atomic orbital layer
         self.ao = AtomicOrbitals(mol, cuda)
@@ -69,7 +69,8 @@ def __init__(
         # 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 = 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:
@@ -78,7 +79,8 @@ def __init__(
         # 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))
+        self.mo.weight = nn.Parameter(
+            torch.eye(self.nmo_opt, self.nmo_opt))
         if self.cuda:
             self.mo.to(self.device)
 
@@ -87,59 +89,69 @@ def __init__(
         self.use_jastrow = False
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method, self.configs, mol, cuda)
+        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.0)
-        self.fc.weight.data[0][0] = 1.0
+        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":
+        if kinetic == 'jacobi':
             self.kinetic_energy = self.kinetic_energy_jacobi
 
-        gradients = "auto"
+        gradients = 'auto'
         self.gradients_method = gradients
-        if gradients == "jacobi":
+        if gradients == 'jacobi':
             self.gradients = self.gradients_jacobi
 
         if self.cuda:
-            self.device = torch.device("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"])
+        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)
+        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.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      : ")
+        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()])
+            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)
+        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))
+            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())
+        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]
+            mo_coeff = mo_coeff[:, :self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -157,19 +169,21 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-            xyz = self.ao.atom_coords[iat, :].cpu().detach().numpy().tolist()
+
+            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
+            The SZ sto that have only one basis function per ao
         """
 
-        assert self.ao.radial_type.startswith("gto")
-        assert self.ao.harmonics_type == "cart"
+        assert(self.ao.radial_type.startswith('gto'))
+        assert(self.ao.harmonics_type == 'cart')
 
-        log.info("  Fit GTOs to STOs  : ")
+        log.info('  Fit GTOs to STOs  : ')
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -183,7 +197,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = "sto_pure"
+        basis.radial_type = 'sto_pure'
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -201,12 +215,14 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -217,15 +233,12 @@ def sto(x, norm, alpha):
             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()
-            )
+            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:
@@ -237,13 +250,10 @@ def sto(x, norm, alpha):
         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,
-        )
+        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
@@ -265,11 +275,11 @@ def forward(self, x, ao=None):
             >>> vals = wf(pos)
         """
 
-        raise NotImplementedError("Implement a forward method")
+        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")
+        raise NotImplementedError('Implement a ao2mo method')
 
     def pos2mo(self, x, derivative=0):
         """Get the values of MOs from the positions
@@ -283,9 +293,9 @@ def pos2mo(self, x, derivative=0):
         Returns:
             torch.tensor -- MO matrix [nbatch, nelec, nmo]
         """
-        raise NotImplementedError("Implement a get_mo_vals method")
+        raise NotImplementedError('Implement a get_mo_vals method')
 
-    def kinetic_energy_jacobi(self, x, **kwargs):
+    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 .
 
@@ -299,7 +309,8 @@ def kinetic_energy_jacobi(self, x, **kwargs):
             torch.tensor: values of the kinetic energy at each sampling points
         """
 
-        raise NotImplementedError("Implement a kinetic_energy_jacobi method")
+        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
@@ -316,7 +327,8 @@ def gradients_jacobi(self, x, pdf=False):
             torch.tensor: values of the gradients wrt the walker pos at each sampling points
         """
 
-        raise NotImplementedError("Implement a gradient_jacobi method")
+        raise NotImplementedError(
+            'Implement a gradient_jacobi method')
 
     def get_gradient_operator(self, x, ao, grad_ao, mo):
         """Compute the gradient operator
@@ -327,9 +339,10 @@ def get_gradient_operator(self, x, ao, grad_ao, mo):
             dao ([type]): [description]
         """
 
-        raise NotImplementedError("Implement a get_grad_operator method")
+        raise NotImplementedError(
+            'Implement a get_grad_operator method')
 
-    def get_hessian_operator(self, x, ao, dao, d2ao, mo):
+    def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
         """Compute the Bkin matrix
 
         Args:
@@ -340,4 +353,5 @@ def get_hessian_operator(self, x, ao, dao, d2ao, mo):
             torch.tensor: matrix of the kinetic operator
         """
 
-        raise NotImplementedError("Implement a get_kinetic_operator method")
+        raise NotImplementedError(
+            'Implement a get_kinetic_operator method')
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_graph.py b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
index 727fce01..2d5c7a19 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_graph.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
@@ -1,30 +1,27 @@
+
+
 import numpy as np
 import torch
 from .slater_jastrow import SlaterJastrow
 
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import (
-    JastrowFactorElectronElectron,
-)
+from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 
 from .jastrows.graph.jastrow_graph import JastrowFactorGraph
 from .jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
 
 
 class SlaterJastrowGraph(SlaterJastrow):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        ee_model=MGCNPredictor,
-        ee_model_kwargs={},
-        en_model=MGCNPredictor,
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-        include_all_mo=True,
-    ):
+
+    def __init__(self, mol, configs='ground_state',
+                 kinetic='jacobi',
+                 ee_model=MGCNPredictor,
+                 ee_model_kwargs={},
+                 en_model=MGCNPredictor,
+                 en_model_kwargs={},
+                 atomic_features=["atomic_number"],
+                 cuda=False,
+                 include_all_mo=True):
         """Implementation of a SlaterJastrow Network using Graph neural network to express the Jastrow.
 
         Args:
@@ -46,23 +43,19 @@ def __init__(
 
         super().__init__(mol, configs, kinetic, None, None, cuda, include_all_mo)
 
-        self.jastrow_type = "Graph(ee:%s, en:%s)" % (
-            ee_model.__name__,
-            en_model.__name__,
-        )
+        self.jastrow_type = 'Graph(ee:%s, en:%s)' % (
+            ee_model.__name__, en_model.__name__)
         self.use_jastrow = True
-        self.jastrow = JastrowFactorGraph(
-            mol.nup,
-            mol.ndown,
-            torch.as_tensor(mol.atom_coords),
-            mol.atoms,
-            ee_model=ee_model,
-            ee_model_kwargs=ee_model_kwargs,
-            en_model=en_model,
-            en_model_kwargs=en_model_kwargs,
-            atomic_features=atomic_features,
-            cuda=cuda,
-        )
+        self.jastrow = JastrowFactorGraph(mol.nup, mol.ndown,
+                                          torch.as_tensor(
+                                              mol.atom_coords),
+                                          mol.atoms,
+                                          ee_model=ee_model,
+                                          ee_model_kwargs=ee_model_kwargs,
+                                          en_model=en_model,
+                                          en_model_kwargs=en_model_kwargs,
+                                          atomic_features=atomic_features,
+                                          cuda=cuda)
 
         if self.cuda:
             self.jastrow = self.jastrow.to(self.device)
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index e0067a71..85fb5e55 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -4,7 +4,9 @@
 
 
 class WaveFunction(torch.nn.Module):
-    def __init__(self, nelec, ndim, kinetic="auto", cuda=False):
+
+    def __init__(self, nelec, ndim, kinetic='auto', cuda=False):
+
         super(WaveFunction, self).__init__()
 
         self.ndim = ndim
@@ -12,14 +14,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.
+        ''' Compute the value of the wave function.
         for a multiple conformation of the electrons
 
         Args:
@@ -27,7 +29,7 @@ def forward(self, x):
             pos: position of the electrons
 
         Returns: values of psi
-        """
+        '''
 
         raise NotImplementedError()
 
@@ -47,11 +49,13 @@ 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.0 / r
+                epos2 = pos[:, ielec2 *
+                            self.ndim:(ielec2 + 1) * self.ndim]
+                r = torch.sqrt(((epos1 - epos2)**2).sum(1))  # + 1E-12
+                pot += (1. / r)
         return pot.view(-1, 1)
 
     def nuclear_potential(self, pos):
@@ -75,7 +79,7 @@ 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)
 
@@ -89,14 +93,14 @@ def nuclear_repulsion(self):
             torch.tensor: values of the nuclear-nuclear energy at each sampling points
         """
 
-        vnn = 0.0
+        vnn = 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
 
@@ -114,11 +118,13 @@ 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
 
@@ -137,16 +143,21 @@ 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]
 
@@ -155,66 +166,64 @@ def kinetic_energy_autograd(self, pos):
     def local_energy(self, pos):
         """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)
+         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)
-
-        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."""
+        '''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."""
+        '''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."""
+        '''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."""
+        '''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."""
+        '''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."""
+        '''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):
         """Computes the total number of parameters."""
@@ -224,7 +233,7 @@ def get_number_parameters(self):
                 nparam += param.data.numel()
         return nparam
 
-    def load(self, filename, group="wf_opt", model="best"):
+    def load(self, filename, group='wf_opt', model='best'):
         """Load trained parameters
 
         Args:
@@ -233,8 +242,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 6f8f9bf1..20159170 100644
--- a/setup.py
+++ b/setup.py
@@ -2,64 +2,54 @@
 
 import os
 
-from setuptools import find_packages, setup
+from setuptools import (find_packages, setup)
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 # To update the package version number, edit QMCTorch/__version__.py
 version = {}
-with open(os.path.join(here, "qmctorch", "__version__.py")) as f:
+with open(os.path.join(here, 'qmctorch', '__version__.py')) as f:
     exec(f.read(), version)
 
-with open("README.md") as readme_file:
+with open('README.md') as readme_file:
     readme = readme_file.read()
 
 setup(
-    name="qmctorch",
-    version=version["__version__"],
+    name='qmctorch',
+    version=version['__version__'],
     description="Pytorch Implementation of Quantum Monte Carlo",
-    long_description=readme + "\n\n",
-    long_description_content_type="text/markdown",
+    long_description=readme + '\n\n',
+    long_description_content_type='text/markdown',
     author=["Nicolas Renaud", "Felipe Zapata"],
-    author_email="n.renaud@esciencecenter.nl",
-    url="https://github.com/NLESC-JCER/QMCTorch",
+    author_email='n.renaud@esciencecenter.nl',
+    url='https://github.com/NLESC-JCER/QMCTorch',
     packages=find_packages(),
-    package_dir={"qmctorch": "qmctorch"},
+    package_dir={'qmctorch': 'qmctorch'},
     include_package_data=True,
     license="Apache Software License 2.0",
     zip_safe=False,
-    keywords="qmctorch",
-    scripts=["bin/qmctorch"],
+    keywords='qmctorch',
+    scripts=['bin/qmctorch'],
     classifiers=[
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Science/Research",
-        "License :: OSI Approved :: Apache Software License",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Topic :: Scientific/Engineering :: Chemistry",
-    ],
-    test_suite="tests",
-    install_requires=[
-        "matplotlib",
-        "numpy",
-        "argparse",
-        "scipy",
-        "tqdm",
-        "torch",
-        "dgl",
-        "dgllife",
-        "plams",
-        "pints",
-        "pyscf",
-        "mendeleev",
-        "twiggy",
-        "plams",
-        "mpi4py",
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: Apache Software License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Topic :: Scientific/Engineering :: Chemistry'
     ],
+    test_suite='tests',
+    install_requires=['matplotlib', 'numpy', 'argparse',
+                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
+                      'plams', 'pints',
+                      'pyscf', 'mendeleev', 'twiggy',
+                      'plams', 'mpi4py'],
+
     extras_require={
-        "hpc": ["horovod==0.27.0"],
-        "doc": ["recommonmark", "sphinx", "sphinx_rtd_theme", "nbsphinx"],
-        "test": ["pytest", "pytest-runner", "coverage", "coveralls", "pycodestyle"],
-    },
+        'hpc': ['horovod==0.27.0'],
+        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx'],
+        'test': ['pytest', 'pytest-runner',
+                 'coverage', 'coveralls', 'pycodestyle'],
+    }
 )
diff --git a/tests/path_utils.py b/tests/path_utils.py
index 382fd948..3e7d13af 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 0545b468..70851a4b 100644
--- a/tests/sampler/test_generalized_metropolis.py
+++ b/tests/sampler/test_generalized_metropolis.py
@@ -5,16 +5,13 @@
 
 
 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)
 
diff --git a/tests/sampler/test_hamiltonian.py b/tests/sampler/test_hamiltonian.py
index 8ffb7c8d..88b866a3 100644
--- a/tests/sampler/test_hamiltonian.py
+++ b/tests/sampler/test_hamiltonian.py
@@ -5,6 +5,7 @@
 
 
 class TestHamiltonian(TestSamplerBase):
+
     def test_hmc(self):
         """Test HMC sampler."""
         sampler = Hamiltonian(
@@ -13,8 +14,7 @@ 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)
 
diff --git a/tests/sampler/test_metropolis.py b/tests/sampler/test_metropolis.py
index 7bf41d3d..49ccf446 100644
--- a/tests/sampler/test_metropolis.py
+++ b/tests/sampler/test_metropolis.py
@@ -6,6 +6,7 @@
 
 
 class TestMetropolis(TestSamplerBase):
+
     def test_metropolis(self):
         """Test Metropolis sampling."""
 
@@ -15,12 +16,12 @@ 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']:
 
-        for m in ["one-elec", "all-elec", "all-elec-iter"]:
-            for p in ["normal", "uniform"]:
-                sampler.configure_move({"type": m, "proba": p})
+                sampler.configure_move({'type': m, 'proba': p})
                 pos = sampler(self.wf.pdf)
 
     def test_metropolis_logspace(self):
@@ -32,13 +33,13 @@ def test_metropolis_logspace(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-            logspace=True,
-        )
+            init=self.mol.domain('normal'),
+            logspace=True)
+
+        for m in ['one-elec', 'all-elec', 'all-elec-iter']:
+            for p in ['normal', 'uniform']:
 
-        for m in ["one-elec", "all-elec", "all-elec-iter"]:
-            for p in ["normal", "uniform"]:
-                sampler.configure_move({"type": m, "proba": p})
+                sampler.configure_move({'type': m, 'proba': p})
                 pos = sampler(self.wf.pdf)
 
 
diff --git a/tests/sampler/test_metropolis_hasting.py b/tests/sampler/test_metropolis_hasting.py
index e9a2206d..f8a1c007 100644
--- a/tests/sampler/test_metropolis_hasting.py
+++ b/tests/sampler/test_metropolis_hasting.py
@@ -1,13 +1,11 @@
 import unittest
 from qmctorch.sampler import MetropolisHasting
-from qmctorch.sampler.proposal_kernels import (
-    ConstantVarianceKernel,
-    CenterVarianceKernel,
-)
+from qmctorch.sampler.proposal_kernels import ConstantVarianceKernel, CenterVarianceKernel
 from .test_sampler_base import TestSamplerBase
 
 
 class TestMetropolisHasting(TestSamplerBase):
+
     def test_ConstantKernel(self):
         """Test Metropolis sampling."""
 
@@ -16,9 +14,8 @@ def test_ConstantKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-            kernel=ConstantVarianceKernel(),
-        )
+            init=self.mol.domain('normal'),
+            kernel=ConstantVarianceKernel())
 
         _ = sampler(self.wf.pdf)
 
@@ -30,9 +27,8 @@ def test_CenterVarianceKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-            kernel=CenterVarianceKernel(),
-        )
+            init=self.mol.domain('normal'),
+            kernel=CenterVarianceKernel())
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_pints.py b/tests/sampler/test_pints.py
index 6bb11e35..a4c2674e 100644
--- a/tests/sampler/test_pints.py
+++ b/tests/sampler/test_pints.py
@@ -7,6 +7,7 @@
 
 
 class TestPints(TestSamplerBase):
+
     def test_Haario(self):
         """Test Metropolis sampling."""
 
@@ -15,9 +16,8 @@ def test_Haario(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-            method=pints.HaarioBardenetACMC,
-        )
+            init=self.mol.domain('normal'),
+            method=pints.HaarioBardenetACMC)
 
         _ = sampler(self.wf.pdf)
 
@@ -29,10 +29,9 @@ def test_Langevin(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
+            init=self.mol.domain('normal'),
             method=pints.MALAMCMC,
-            method_requires_grad=True,
-        )
+            method_requires_grad=True)
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index 37862707..b29547b1 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestSamplerBase(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,13 +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)
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
 
         # orbital
         self.wf = SlaterJastrow(self.mol, jastrow=jastrow)
diff --git a/tests/sampler/test_walker.py b/tests/sampler/test_walker.py
index 67131c6f..3554311b 100644
--- a/tests/sampler/test_walker.py
+++ b/tests/sampler/test_walker.py
@@ -5,23 +5,24 @@
 
 
 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")
-        )
+        w1 = 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")
-        )
+        w2 = 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")
-        )
+        w3 = 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")
-        )
+        w4 = 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 9392faa0..31f39f4d 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestGTO2STOFit(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,39 +22,36 @@ 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)
 
-        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(
-            mol, kinetic="auto", configs="ground_state", jastrow=jastrow
-        ).gto2sto()
+        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 = -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 2c68e38b..6ae26223 100644
--- a/tests/scf/test_molecule.py
+++ b/tests/scf/test_molecule.py
@@ -4,49 +4,52 @@
 
 
 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")
+        mol = 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.0, 0.5])).all()
+        domain_center = mol.domain('center')
+        assert (domain_center['center'] ==
+                np.array([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.0, 0.5]))
+        domain_normal = mol.domain('normal')
+        assert np.all(domain_normal['mean']
+                      == np.array([0., 0., 0.5]))
 
-        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]])
-        )
+        domain_atomic = mol.domain('atomic')
+        assert np.all(domain_atomic['atom_coords'] == np.array([[0., 0., 0.],
+                                                                [0., 0., 1.]]))
 
     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
index 13a0565a..594eb2f6 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -6,7 +6,9 @@
 
 
 class BaseTestSolvers:
+
     class BaseTestSolverMolecule(unittest.TestCase):
+
         def setUp(self):
             self.mol = None
             self.wf = None
@@ -18,6 +20,7 @@ def setUp(self):
             self.expected_variance = None
 
         def test1_single_point(self):
+
             # sample and compute observables
             obs = self.solver.single_point()
             e, v = obs.energy, obs.variance
@@ -31,13 +34,13 @@ def test1_single_point(self):
             #         np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
 
         def test2_wf_opt_grad_auto(self):
-            self.solver.configure(
-                track=["local_energy", "parameters"], loss="energy", grad="auto"
-            )
+
+            self.solver.configure(track=['local_energy', 'parameters'],
+                                  loss='energy', grad='auto')
             _ = self.solver.run(5)
 
         def test3_wf_opt_grad_manual(self):
-            self.solver.configure(
-                track=["local_energy", "parameters"], loss="energy", grad="manual"
-            )
+
+            self.solver.configure(track=['local_energy', 'parameters'],
+                                  loss='energy', grad='manual')
             _ = self.solver.run(5)
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index 1fccd751..aabaf28e 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -19,20 +19,23 @@
 
 
 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)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='auto',
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -41,20 +44,24 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1572532653808594, -1.1501641653648578]
+        self.expected_energy = [-1.1572532653808594,
+                                -1.1501641653648578]
 
-        self.expected_variance = [0.05085879936814308, 0.05094174843043177]
+        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 61143675..950a7686 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -14,19 +14,21 @@
 
 
 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)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='single(2,2)', jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -35,20 +37,24 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1571345329284668, -1.1501641653648578]
+        self.expected_energy = [-1.1571345329284668,
+                                -1.1501641653648578]
 
-        self.expected_variance = [0.05087674409151077, 0.05094174843043177]
+        self.expected_variance = [0.05087674409151077,
+                                  0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index b61e8e50..ff62759e 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -6,13 +6,10 @@
 
 
 from qmctorch.sampler import Metropolis
-from qmctorch.utils.plot_data 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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
@@ -22,7 +19,9 @@
 
 
 class TestH2GeoOpt(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -32,19 +31,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="auto", configs="single(2,2)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol,
+                                kinetic='auto',
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -53,25 +52,31 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
     def test_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.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.load(self.solver.hdf5file, 'geo_opt')
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -83,8 +88,8 @@ def test_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert e > 2 * gse and e < 0.0
-        assert v > 0 and v < 2.0
+        assert(e > 2 * gse and e < 0.)
+        assert(v > 0 and v < 2.)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index 3c20711f..d02680d3 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -17,7 +17,9 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -27,19 +29,18 @@ 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="auto", configs="single(2,2)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='auto',
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -47,20 +48,22 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-        )
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925, -1.088576]
+        self.expected_energy = [-1.0877732038497925,
+                                -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732, 0.163771]
+        self.expected_variance = [0.14341972768306732,
+                                  0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index f7702dc8..6951f435 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -17,7 +17,9 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -27,19 +29,18 @@ 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)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -47,20 +48,22 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("normal"),
-        )
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925, -1.088576]
+        self.expected_energy = [-1.0877732038497925,
+                                -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732, 0.163771]
+        self.expected_variance = [0.14341972768306732,
+                                  0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 895dca4a..15bc1f28 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -18,7 +18,9 @@
 
 
 class TestH2SamplerMH(BaseTestSolvers.BaseTestSolverMolecule):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -28,19 +30,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="auto", configs="single(2,2)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol,
+                                kinetic='auto',
+                                configs='single(2,2)',
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -49,31 +51,39 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler,
+                                          optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.1464850902557373, -1.14937478612449]
+        self.expected_energy = [-1.1464850902557373,
+                                -1.14937478612449]
 
         # values on different arch
-        self.expected_variance = [0.9279592633247375, 0.7445300449383236]
+        self.expected_variance = [0.9279592633247375,
+                                  0.7445300449383236]
 
     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.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.load(self.solver.hdf5file, 'geo_opt')
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -85,8 +95,8 @@ def test4_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert e > 2 * gse and e < 0.0
-        assert v > 0 and v < 2.0
+        assert(e > 2 * gse and e < 0.)
+        assert(v > 0 and v < 2.)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index 1cecf465..76f77ddd 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,20 +6,19 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
-from qmctorch.utils.plot_data 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.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)
 
@@ -29,19 +28,17 @@ 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)", jastrow=jastrow
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='single(2,2)', jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -52,17 +49,20 @@ 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)
 
@@ -70,6 +70,7 @@ 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)
 
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index 606ed2b4..ec91a8ff 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -8,10 +8,7 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import (
-    BackFlowTransformation,
-    BackFlowKernelInverse,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -20,13 +17,16 @@
 
 
 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
@@ -34,26 +34,21 @@ def setUp(self):
 
         # backflow
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=False
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=False)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol,
-            kinetic="jacobi",
-            jastrow=jastrow,
-            backflow=backflow,
-            configs="single_double(2,2)",
-            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(
@@ -62,19 +57,22 @@ 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
 
 
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index c64b46a7..5ceceafc 100644
--- a/tests/solver/test_lih_correlated.py
+++ b/tests/solver/test_lih_correlated.py
@@ -14,19 +14,23 @@
 
 
 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)
@@ -42,28 +46,35 @@ 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
@@ -78,7 +89,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")
+        self.solver.configure(track=['local_energy'],
+                              loss='energy', grad='manual')
         obs = self.solver.run(5)
 
 
diff --git a/tests/solver/test_lih_pyscf.py b/tests/solver/test_lih_pyscf.py
index 20be58b7..e287934c 100644
--- a/tests/solver/test_lih_pyscf.py
+++ b/tests/solver/test_lih_pyscf.py
@@ -14,29 +14,26 @@
 
 
 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",
-        )
+            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,
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='single(2,2)',
+                                include_all_mo=False, jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -45,15 +42,17 @@ 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)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 8fc7c199..1d6cc922 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -9,10 +9,7 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import (
-    BackFlowTransformation,
-    BackFlowKernelInverse,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -20,44 +17,40 @@
 
 
 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
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=False)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol,
-            kinetic="jacobi",
-            jastrow=jastrow,
-            backflow=backflow,
-            configs="single_double(2,2)",
-            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(
@@ -66,19 +59,22 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index fdcff7ba..dec3033a 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -10,10 +10,7 @@
 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,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
 
 
@@ -23,58 +20,49 @@ 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
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=False)
 
         # backflow wave function
-        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 = 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.
         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,
-            jastrow=jastrow_ref,
-            backflow=None,
-            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)
@@ -83,13 +71,10 @@ 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
@@ -99,9 +84,10 @@ 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(
@@ -110,9 +96,10 @@ 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()
@@ -122,18 +109,20 @@ 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)
@@ -143,9 +132,11 @@ 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()
@@ -163,52 +154,58 @@ 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 0b5156be..d8486308 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -9,10 +9,7 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import (
-    BackFlowTransformation,
-    BackFlowKernelPowerSum,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelPowerSum
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -20,44 +17,40 @@
 
 
 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
-        )
+            self.mol, BackFlowKernelPowerSum, orbital_dependent=False)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol,
-            kinetic="jacobi",
-            jastrow=jastrow,
-            backflow=backflow,
-            configs="single_double(2,2)",
-            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(
@@ -66,19 +59,22 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
index c43e3564..c76ba7ce 100644
--- a/tests/solver/test_lih_pyscf_generic_jastrow.py
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -8,40 +8,35 @@
 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.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",
-        )
+            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,
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='single(2,2)',
+                                include_all_mo=False,
+                                jastrow=jastrow)
 
         # sampler
         self.sampler = Metropolis(
@@ -50,19 +45,22 @@ 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 test2_wf_opt_grad_auto(self):
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index a4202d89..118d994d 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -9,10 +9,7 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import (
-    BackFlowTransformation,
-    BackFlowKernelInverse,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -20,44 +17,40 @@
 
 
 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
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=True)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol,
-            kinetic="jacobi",
-            jastrow=jastrow,
-            backflow=backflow,
-            configs="single_double(2,2)",
-            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(
@@ -66,19 +59,22 @@ 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
 
 
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index b8229b52..6a74199f 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -2,54 +2,60 @@
 
 import torch
 
-from qmctorch.utils import InterpolateAtomicOrbitals, InterpolateMolecularOrbitals
+from qmctorch.utils import (InterpolateAtomicOrbitals,
+                            InterpolateMolecularOrbitals)
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 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)
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
-        )
+        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")
+        inter = interp_mo(self.pos, method='reg')
         ref = self.wf.mo(self.wf.mo_scf(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")
+        inter = interp_mo(self.pos, method='irreg')
         ref = self.wf.mo(self.wf.mo_scf(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
index 9a1a940f..bfa699bb 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -8,16 +8,21 @@
 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]
 
@@ -25,7 +30,9 @@ def hess(out, pos):
 
 
 class BaseTestCases:
+
     class WaveFunctionBaseTest(unittest.TestCase):
+
         def setUp(self):
             """Init the base test"""
             self.pos = None
@@ -43,10 +50,8 @@ def test_antisymmetry(self):
 
             if self.wf.nelec < 4:
                 print(
-                    "Warning : antisymmetry cannot be tested with \
-                        only %d electrons"
-                    % self.wf.nelec
-                )
+                    'Warning : antisymmetry cannot be tested with \
+                        only %d electrons' % self.wf.nelec)
                 return
 
             # test spin up
@@ -55,21 +60,23 @@ def test_antisymmetry(self):
             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)
+            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)
+            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
+            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)
+            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)
+            assert(torch.allclose(wfvals_ref, -1*wfvals_xdn))
 
         def test_grad_mo(self):
             """Gradients of the MOs."""
@@ -77,14 +84,16 @@ def test_grad_mo(self):
             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]
+            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)
-            )
+            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."""
@@ -93,62 +102,71 @@ def test_hess_mo(self):
             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(), 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).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)
-            )
+            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)
+            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)
+            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()
+
+            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)
+            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)
+            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())
+            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 = 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)
+            assert(torch.allclose(psum_mo, psum_mo_grad))
 
         def test_grad_mo(self):
             """Gradients of the BF MOs."""
@@ -158,13 +176,15 @@ def test_grad_mo(self):
             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_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)
+            assert(torch.allclose(dmo, dmo_grad))
 
         def test_hess_mo(self):
             """Hessian of the MOs."""
@@ -174,12 +194,14 @@ def test_hess_mo(self):
             d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
             d2val = self.wf.ao2mo(d2ao)
 
-            assert torch.allclose(d2val.sum(), d2val_grad.sum())
+            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 = 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)
+            assert(torch.allclose(d2val, d2val_grad))
 
         def test_gradients_wf(self):
             pass
diff --git a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
index b843c7a4..f0560f72 100644
--- a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
+++ b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
@@ -9,16 +9,21 @@
 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]
 
@@ -26,6 +31,7 @@ def hess(out, pos):
 
 
 class TestElecElecDistance(unittest.TestCase):
+
     def setUp(self):
         self.nup, self.ndown = 1, 1
         self.nelec = self.nup + self.ndown
@@ -66,14 +72,15 @@ 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/base_elec_elec_jastrow_test.py b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
index 9f5b5ed5..745bb179 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -8,16 +8,21 @@
 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]
 
@@ -25,7 +30,9 @@ def hess(out, pos):
 
 
 class BaseTestJastrow:
+
     class ElecElecJastrowBaseTest(unittest.TestCase):
+
         def setUp(self) -> None:
             """Init the test case"""
             self.jastrow = None
@@ -37,6 +44,7 @@ def test_jastrow(self):
             val = self.jastrow(self.pos)
 
         def test_permutation(self):
+
             jval = self.jastrow(self.pos)
 
             # test spin up
@@ -45,48 +53,64 @@ def test_permutation(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)
 
             jval_xup = self.jastrow(pos_xup)
-            assert torch.allclose(jval, jval_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]
+            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_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 = 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_grad_jastrow(self):
+
             val = self.jastrow(self.pos)
-            dval = self.jastrow(self.pos, derivative=1, sum_grad=False)
+            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 = 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, dval_grad.transpose(1, 2))
-            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, d2val_grad.view(
+                self.nbatch, self.nelec, 3).sum(2))
 
-            assert torch.allclose(d2val.sum(), d2val_grad.sum())
+            assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index dc9d78a3..ef8fa1cc 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -1,3 +1,4 @@
+
 import unittest
 import numpy as np
 import torch
@@ -6,28 +7,28 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestGenericJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
         mol = SimpleNamespace(nup=4, ndown=4)
         self.nelec = mol.nup + mol.ndown
 
-        self.jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
+        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
 
 
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 4f6fd241..7bb0a1da 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -5,18 +5,16 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -24,8 +22,9 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, 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)
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 43dc6135..13a33a17 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -1,3 +1,4 @@
+
 import unittest
 import numpy as np
 import torch
@@ -7,18 +8,16 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -26,14 +25,10 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            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)
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 9dca1be1..4d7bdbcf 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -5,18 +5,16 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -24,8 +22,10 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, 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)
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 d6f29843..626d7535 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,3 +1,4 @@
+
 import unittest
 import numpy as np
 import torch
@@ -7,18 +8,16 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import PadeJastrowPolynomialKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -26,15 +25,11 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            PadeJastrowPolynomialKernel,
-            kernel_kwargs={
-                "order": 5,
-                "weight_a": 0.1 * torch.ones(5),
-                "weight_b": 0.1 * torch.ones(5),
-            },
-            scale=True,
-        )
+            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)
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 3e27287e..5d116766 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
@@ -15,19 +15,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 4ca2034a..d7c3f2c1 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
@@ -3,12 +3,8 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
-    BoysHandyJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -16,16 +12,21 @@
 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,46 +34,55 @@ 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 * np.random.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
-        )
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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
@@ -81,41 +91,54 @@ 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 3abeddc5..1227ba48 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
@@ -3,12 +3,8 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
-    FullyConnectedJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -16,16 +12,21 @@
 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,72 +34,92 @@ 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
-        )
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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/test_electron_nuclei_fully_connected.py b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
index 1d793868..f019dcbc 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
@@ -3,12 +3,8 @@
 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 import (
-    FullyConnectedJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import FullyConnectedJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -16,16 +12,21 @@
 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,7 +34,9 @@ def hess(out, pos):
 
 
 class TestElectronNucleiGeneric(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -41,41 +44,50 @@ def setUp(self):
         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
-        )
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
         self.jastrow = JastrowFactorElectronNuclei(
-            self.mol, 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 e9f995b2..832beb5d 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
@@ -4,12 +4,8 @@
 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.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels.pade_jastrow_kernel import PadeJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -17,16 +13,21 @@
 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]
 
@@ -34,7 +35,9 @@ def hess(out, pos):
 
 
 class TestElectronNucleiPadeJastrow(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -42,40 +45,51 @@ def setUp(self):
         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.mol, PadeJastrowKernel)
+            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/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index 67ac08ab..a9bb3d1b 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -12,16 +12,21 @@
 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]
 
@@ -29,7 +34,9 @@ def hess(out, pos):
 
 
 class TestGraphJastrow(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -38,27 +45,29 @@ def setUp(self):
         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 = JastrowFactorGraph(
-            self.mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-        )
+        self.mol = SimpleNamespace(nup=self.nup, ndown=self.ndown,
+                                   atom_coords=self.atomic_pos,
+                                   atoms=self.atom_types)
+
+        self.jastrow = JastrowFactorGraph(self.mol,
+                                          ee_model=MGCNPredictor,
+                                          ee_model_kwargs={'n_layers': 3,
+                                                           'feats': 32,
+                                                           'cutoff': 5.0,
+                                                           'gap': 1.},
+                                          en_model=MGCNPredictor,
+                                          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 = -1. + 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
@@ -67,41 +76,54 @@ def test_permutation(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)
 
         jval_xup = self.jastrow(pos_xup)
-        assert torch.allclose(jval, jval_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 = 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_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, dval_grad.transpose(1, 2))
-        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, d2val_grad.view(
+            self.nbatch, self.nelec, 3).sum(2))
 
-        assert torch.allclose(d2val.sum(), d2val_grad.sum())
+        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index a68ad541..e53b5216 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -4,19 +4,10 @@
 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, FullyConnectedJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -24,16 +15,21 @@
 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,7 +37,9 @@ def hess(out, pos):
 
 
 class TestJastrowCombinedTerms(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -50,18 +48,20 @@ def setUp(self):
         self.atoms = np.random.rand(4, 3)
 
         self.mol = SimpleNamespace(
-            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
-        )
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
 
         self.jastrow = JastrowFactorCombinedTerms(
             self.mol,
             jastrow_kernel={
-                "ee": PadeJastrowKernelElecElec,
-                "en": PadeJastrowKernelElecNuc,
-                "een": BoysHandyJastrowKernel,
+                'ee': PadeJastrowKernelElecElec,
+                'en': PadeJastrowKernelElecNuc,
+                'een': BoysHandyJastrowKernel
             },
-            jastrow_kernel_kwargs={"ee": {"w": 1.0}, "en": {"w": 1.0}, "een": {}},
-        )
+            jastrow_kernel_kwargs={
+                'ee': {'w': 1.},
+                'en': {'w': 1.},
+                'een': {}
+            })
 
         self.nbatch = 5
 
@@ -72,23 +72,30 @@ def test_jastrow(self):
         val = 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/test_backflow_kernel_generic_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
index 1c7fd230..4be0c43f 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -8,10 +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 qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -19,18 +16,24 @@
 
 
 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,29 +41,36 @@ 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 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:
@@ -78,11 +88,16 @@ def _backflow_kernel(self, ree):
 
 
 class TestGenericBackFlowKernel(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 kernel
         self.kernel = GenericBackFlowKernel(self.mol)
@@ -96,21 +111,20 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-        wrt the elec-elec distance."""
+            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_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)
+        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."""
+           wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -119,8 +133,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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)
+        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.
@@ -142,7 +156,8 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(ree, derivative=1)
+        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
@@ -155,14 +170,16 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(
+            bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert torch.allclose(d_bfpos.sum(), dbfpos_grad.sum())
+        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)
+        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.
@@ -189,30 +206,29 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += (
-            self.kernel(ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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())
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2,
+                                                  1).reshape(self.npts, -1)
 
-        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
+        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
 
 
 if __name__ == "__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 e9a4c6aa..0001d1cd 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -7,10 +7,7 @@
 
 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.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -18,18 +15,24 @@
 
 
 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]
 
@@ -37,27 +40,39 @@ 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 TestBackFlowKernel(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 kernel
         self.kernel = BackFlowKernelInverse(self.mol)
@@ -71,21 +86,20 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-        wrt the elec-elec distance."""
+            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_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)
+        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."""
+           wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -94,8 +108,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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)
+        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.
@@ -117,7 +131,8 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(ree, derivative=1)
+        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
@@ -130,14 +145,16 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(
+            bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert torch.allclose(d_bfpos.sum(), dbfpos_grad.sum())
+        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)
+        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.
@@ -164,30 +181,29 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += (
-            self.kernel(ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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())
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2,
+                                                  1).reshape(self.npts, -1)
 
-        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
+        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index a2fc1efd..4334c918 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -5,11 +5,8 @@
 from torch.autograd import Variable, grad, gradcheck
 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
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -17,18 +14,24 @@
 
 
 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,30 +39,43 @@ 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 TestBackFlowTransformation(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 backflow transformation
-        self.backflow_trans = BackFlowTransformation(self.mol, BackFlowKernelInverse)
+        self.backflow_trans = BackFlowTransformation(
+            self.mol, BackFlowKernelInverse)
 
         # define the grid points
         self.npts = 11
@@ -79,17 +95,18 @@ def test_backflow_derivative(self):
 
         # 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]
+        dq_grad = grad(
+            q, self.pos, grad_outputs=torch.ones_like(self.pos))[0]
 
         # checksum
-        assert torch.allclose(dq.sum(), dq_grad.sum())
+        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)
+        assert(torch.allclose(dq, dq_grad))
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -106,14 +123,14 @@ def test_backflow_second_derivative(self):
         d2q_auto = hess(q, self.pos)
 
         # checksum
-        assert torch.allclose(d2q.sum(), d2q_auto.sum())
+        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)
+        assert(torch.allclose(d2q, d2q_auto))
 
 
 if __name__ == "__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 7d06f969..eb5d1d03 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
@@ -5,11 +5,8 @@
 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
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -17,18 +14,24 @@
 
 
 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,32 +39,43 @@ 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 TestOrbitalDependentBackFlowTransformation(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 backflow transformation
         self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=True)
 
         # set the weights to random
         for ker in self.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -90,23 +104,21 @@ def test_backflow_derivative(self):
         for iq in range(nao):
             qao = q[:, iq, ...]
             dqao = grad(
-                qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True
-            )[0]
+                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
-                )
+                    (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis)
         # checksum
-        assert torch.allclose(dq.sum(), dq_grad.sum())
+        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)
+        assert(torch.allclose(dq, dq_grad))
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -129,19 +141,18 @@ def test_backflow_second_derivative(self):
                 d2q_auto = d2qao
             else:
                 d2q_auto = torch.cat(
-                    (d2q_auto, d2qao),
-                    axis=self.backflow_trans.backflow_kernel.stack_axis,
-                )
+                    (d2q_auto, d2qao), axis=self.backflow_trans.backflow_kernel.stack_axis)
 
         # checksum
-        assert torch.allclose(d2q.sum(), d2q_auto.sum())
+        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)
+        d2q_auto = d2q_auto.reshape(
+            self.npts, nao,  self.mol.nelec, 3)
 
-        assert torch.allclose(d2q, d2q_auto)
+        assert(torch.allclose(d2q, d2q_auto))
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index df4d0671..dd06a9fc 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -6,16 +6,21 @@
 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]
 
@@ -23,77 +28,92 @@ 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]
 
-        hess[:, k] = tmp[:, ix + 1]
+        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]
+        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 BaseTestAO:
+
     class BaseTestAOderivatives(unittest.TestCase):
+
         def setUp(self):
             self.ao = None
             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]
+            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())
+            assert(torch.allclose(dao.sum(), dao_grad.sum()))
 
         def test_ao_grad_sum(self):
+
             ao = 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))
+            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())
+            assert(torch.allclose(d2ao.sum(), d2ao_grad.sum()))
 
         def test_ao_hess_sum(self):
+
             ao = 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))
+            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])
+            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))
diff --git a/tests/wavefunction/orbitals/second_derivative.py b/tests/wavefunction/orbitals/second_derivative.py
index f9fa2d4d..154c5209 100644
--- a/tests/wavefunction/orbitals/second_derivative.py
+++ b/tests/wavefunction/orbitals/second_derivative.py
@@ -1,2 +1,3 @@
+
 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 0ca0a892..6038d514 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -9,16 +9,17 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
index b3389f02..b4f06eb8 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
@@ -8,19 +8,23 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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")
+        at = 'Li 0 0 0; H 0 0 1'
+        basis = 'dzp'
+        self.mol = Molecule(atom=at,
+                            calculator='pyscf',
+                            basis=basis,
+                            unit='bohr')
 
         # define the aos
         self.ao = AtomicOrbitals(self.mol)
diff --git a/tests/wavefunction/orbitals/test_ao_values_adf.py b/tests/wavefunction/orbitals/test_ao_values_adf.py
index 774159f7..7537109d 100644
--- a/tests/wavefunction/orbitals/test_ao_values_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_adf.py
@@ -16,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
 
 
@@ -33,46 +33,52 @@ 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
 
+    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.0] * nao
-            var[iao] = 1.0
-            name = "AO%d" % iao
-            kf.write("Basis", name, var)
+
+            var = [0.] * nao
+            var[iao] = 1.
+            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.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 = 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("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
@@ -88,13 +94,17 @@ def setUp(self):
         self.pos.requires_grad = True
 
     def test_ao(self):
+
         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)
 
@@ -109,7 +119,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 a4c6642e..8215619d 100644
--- a/tests/wavefunction/orbitals/test_ao_values_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
@@ -13,13 +13,18 @@
 
 
 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.ao = AtomicOrbitals(self.mol)
@@ -36,36 +41,44 @@ 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.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.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 9bb50ff1..c4a19bc5 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -6,14 +6,9 @@
 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.backflow.backflow_transformation import (
-    BackFlowTransformation,
-)
+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
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -21,18 +16,24 @@
 
 
 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]
 
@@ -40,31 +41,42 @@ 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
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=False)
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -82,48 +94,53 @@ 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 487883b4..ccc1c754 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -8,18 +8,24 @@
 
 
 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]
 
@@ -27,59 +33,69 @@ 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]
 
-        hess[:, k] = tmp[:, ix + 1]
+        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]
+        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):
@@ -89,12 +105,14 @@ def test_value(self):
     def test_grad(self):
         xyz, r = 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()
@@ -102,7 +120,8 @@ def test_jac(self):
         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()
@@ -110,7 +129,8 @@ def test_lap(self):
         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()
@@ -118,7 +138,8 @@ def test_mixed_der(self):
         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 aa09cfbd..0280b0d1 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -11,24 +11,29 @@
 
 
 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.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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(
+            xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -38,22 +43,24 @@ 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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(
+            xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -63,41 +70,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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
+        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)
+            assert(np.all(delta < 1E-3))
+
+    def test_laplacian(self, eps=1E-4):
 
-    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
@@ -119,9 +131,11 @@ def test_laplacian(self, eps=1e-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.harmonics(xyz, derivative=[0, 1, 2], sum_grad=False)
+        R, dR, 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)
 
@@ -129,8 +143,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]
@@ -143,11 +157,12 @@ 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)
@@ -157,11 +172,13 @@ def test_lap_sum(self):
         npts = 100
         self.pos = torch.rand(npts, self.mol.nelec * 3)
         xyz, r = self.ao._process_position(self.pos)
-        d2R_sum = self.ao.harmonics(xyz, derivative=2, sum_hess=True)
+        d2R_sum = self.ao.harmonics(
+            xyz, derivative=2, sum_hess=True)
 
-        d2R = self.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 73841d09..331cdfe5 100644
--- a/tests/wavefunction/orbitals/test_mo_values_adf.py
+++ b/tests/wavefunction/orbitals/test_mo_values_adf.py
@@ -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,30 +33,34 @@ 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.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 = open('densf_input', 'w')
+    f.write('INPUTFILE %s\n\nCUBOUTPUT MO_\n\n' % t21name)
 
-    f.write("Orbitals SCF\n")
-    f.write("    A occ\n")
-    f.write("    A virt\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')
 
 
 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
@@ -66,21 +70,22 @@ 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()
 
         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)
 
@@ -98,7 +103,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 6947e713..31ee1f11 100644
--- a/tests/wavefunction/orbitals/test_norm.py
+++ b/tests/wavefunction/orbitals/test_norm.py
@@ -6,28 +6,32 @@
 
 
 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])
@@ -37,9 +41,10 @@ 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 0c00b0db..d2351fd3 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
@@ -6,14 +6,9 @@
 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.backflow.backflow_transformation import (
-    BackFlowTransformation,
-)
+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
-
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -21,18 +16,24 @@
 
 
 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]
 
@@ -40,32 +41,43 @@ 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
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True
-        )
+            self.mol, BackFlowKernelInverse, orbital_dependent=True)
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -87,48 +99,53 @@ 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 22ada5f6..a722a88f 100644
--- a/tests/wavefunction/orbitals/test_radial_functions.py
+++ b/tests/wavefunction/orbitals/test_radial_functions.py
@@ -1,27 +1,31 @@
 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]
 
@@ -29,46 +33,52 @@ 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]
 
-        hess[:, k] = tmp[:, ix + 1]
+        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]
+        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
@@ -77,15 +87,16 @@ 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):
@@ -98,51 +109,56 @@ 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 26e3ee7a..b7e90ebe 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -10,35 +10,33 @@
 
 
 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.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.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, 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,29 +46,28 @@ 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.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, 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,46 +77,48 @@ 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.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, 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)
+            assert(np.all(delta < 1E-3))
+
+    def test_laplacian(self, eps=1E-4):
 
-    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         z = torch.linspace(-3, 3, npts)
@@ -140,16 +139,14 @@ def test_laplacian(self, eps=1e-4):
         self.pos[:, 14] = z
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(
-            r,
-            self.ao.bas_n,
-            self.ao.bas_exp,
-            xyz=xyz,
-            derivative=[0, 1, 2],
-            sum_grad=False,
-        )
+        R, dR, 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)
 
@@ -157,8 +154,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]
@@ -174,9 +171,10 @@ 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 9f28fbb1..9883c120 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -12,31 +12,32 @@
 
 
 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.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.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, 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()
@@ -46,29 +47,28 @@ 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.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, 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()
@@ -78,46 +78,48 @@ 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.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, 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)
+            assert(np.all(delta < 1E-3))
+
+    def test_laplacian(self, eps=1E-4):
 
-    def test_laplacian(self, eps=1e-4):
         npts = 1000
 
         self.pos = torch.zeros(npts, self.mol.nelec * 3)
@@ -139,25 +141,23 @@ def test_laplacian(self, eps=1e-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(
-            r,
-            self.ao.bas_n,
-            self.ao.bas_exp,
-            xyz=xyz,
-            derivative=[0, 1, 2],
-            sum_grad=False,
-        )
+        R, dR, 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]
@@ -170,11 +170,12 @@ 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 1451cfd2..4d6b3d4c 100644
--- a/tests/wavefunction/orbitals/test_spherical_harmonics.py
+++ b/tests/wavefunction/orbitals/test_spherical_harmonics.py
@@ -7,11 +7,12 @@
 
 
 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/test_orbconf.py b/tests/wavefunction/pooling/test_orbconf.py
index ef827b58..3b5942e4 100644
--- a/tests/wavefunction/pooling/test_orbconf.py
+++ b/tests/wavefunction/pooling/test_orbconf.py
@@ -9,7 +9,9 @@
 
 
 class TestOrbitalConfiguration(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -17,19 +19,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 dc18ba52..8baf5130 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -9,73 +9,72 @@
 
 
 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.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.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 33abb837..5c7f874e 100644
--- a/tests/wavefunction/pooling/test_trace_trick.py
+++ b/tests/wavefunction/pooling/test_trace_trick.py
@@ -30,7 +30,10 @@ 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
 
@@ -61,21 +64,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]
 
@@ -95,21 +98,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]
 
@@ -131,7 +134,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
@@ -147,7 +150,10 @@ 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)
 
@@ -164,21 +170,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]
 
@@ -201,21 +207,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]
 
@@ -223,16 +229,17 @@ 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.0
+        self.x = 2 * torch.rand(5, 3 * self.mol.nelec) - 1.
         self.x.requires_grad = True
 
     def test_ao_der(self):
@@ -240,20 +247,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
@@ -265,12 +272,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
@@ -281,7 +288,8 @@ 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 1ff3cbc6..992a0c2a 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -5,17 +5,11 @@
 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.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.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
 
@@ -23,7 +17,9 @@
 
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -31,50 +27,43 @@ 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.015',
+            unit='bohr',
+            calculator='pyscf',
+            basis='sto-3g',
+            redo_scf=True)
 
         # define jastrow factor
         jastrow = JastrowFactorElectronElectron(
-            mol,
-            PadeJastrowKernel,
-        )
+            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,
-        )
+            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.
+
+        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,38 +71,43 @@ 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))
+        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__":
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index 487d8b05..e70762d7 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -5,17 +5,11 @@
 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.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.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
 
@@ -23,7 +17,9 @@
 
 
 class TestCompareSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -31,48 +27,44 @@ 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.015',
+            unit='bohr',
+            calculator='pyscf',
+            basis='sto-3g',
+            redo_scf=True)
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+        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,
-        )
+            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)",
-            jastrow=jastrow,
-            backflow=None,
-        )
+        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):
@@ -80,38 +72,43 @@ 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))
+        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__":
diff --git a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
index 11ca4c4c..6f899ae4 100644
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -15,16 +15,21 @@
 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 +37,9 @@ def hess(out, pos):
 
 
 class TestSlaterJastrowGraph(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -40,33 +47,35 @@ 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,
-        )
+            atom='Li 0 0 0; H 0 0 3.14',
+            unit='bohr',
+            calculator='pyscf',
+            basis='sto-3g',
+            redo_scf=True)
 
         # jastrow
-        jastrow = JastrowFactor(
-            mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-        )
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="auto",
-            include_all_mo=False,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-        )
+        jastrow = JastrowFactor(mol,
+                                ee_model=MGCNPredictor,
+                                ee_model_kwargs={'n_layers': 3,
+                                                 'feats': 32,
+                                                 'cutoff': 5.0,
+                                                 'gap': 1.},
+                                en_model=MGCNPredictor,
+                                en_model_kwargs={'n_layers': 3,
+                                                 'feats': 32,
+                                                 'cutoff': 5.0,
+                                                 'gap': 1.0})
+        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):
@@ -79,10 +88,8 @@ def test_antisymmetry(self):
 
         if self.wf.nelec < 4:
             print(
-                "Warning : antisymmetry cannot be tested with \
-                    only %d electrons"
-                % self.wf.nelec
-            )
+                'Warning : antisymmetry cannot be tested with \
+                    only %d electrons' % self.wf.nelec)
             return
 
         # test spin up
@@ -91,21 +98,23 @@ def test_antisymmetry(self):
         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)
+        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)
+        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
+        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)
+        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)
+        assert(torch.allclose(wfvals_ref, -1*wfvals_xdn))
 
     def test_grad_mo(self):
         """Gradients of the MOs."""
@@ -113,14 +122,16 @@ def test_grad_mo(self):
         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]
+        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)
-        )
+        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."""
@@ -129,43 +140,47 @@ def test_hess_mo(self):
         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(), 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).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)
-        )
+        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)
+        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)
+        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()
+
+        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)
+        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)
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 59355b19..4597fb45 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -7,25 +7,19 @@
 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,
-)
+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
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -33,35 +27,33 @@ 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,
-        )
+            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": {}},
-        )
+        jastrow = JastrowFactorCombinedTerms(mol,
+                                             jastrow_kernel={
+                                                 'ee': PadeJastrowKernelElecElec,
+                                                 'en': PadeJastrowKernelElecNuc,
+                                                 'een': BoysHandyJastrowKernel},
+                                             jastrow_kernel_kwargs={
+                                                 'ee': {'w': 1.},
+                                                 'en': {'w': 1.},
+                                                 'een': {}})
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="auto",
-            include_all_mo=False,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index fbb9a6aa..6d4c55f5 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -7,25 +7,13 @@
 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.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
 
@@ -34,7 +22,9 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -42,41 +32,40 @@ 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.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": {}},
-        )
+        jastrow = JastrowFactorCombinedTerms(mol,
+                                             jastrow_kernel={
+                                                 'ee': PadeJastrowKernelElecElec,
+                                                 'en': PadeJastrowKernelElecNuc,
+                                                 'een': BoysHandyJastrowKernel},
+                                             jastrow_kernel_kwargs={
+                                                 'ee': {'w': 1.},
+                                                 'en': {'w': 1.},
+                                                 'een': {}})
 
         # define backflow trans
-        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="jacobi",
-            include_all_mo=True,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-            backflow=backflow,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_internal.py b/tests/wavefunction/test_slatercombinedjastrow_internal.py
index 661a25b3..861cc674 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_internal.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_internal.py
@@ -7,21 +7,17 @@
 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,
-)
+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)
 
@@ -29,29 +25,27 @@ 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,
-        )
+            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.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 = torch.Tensor(np.random.rand(
+            self.nbatch,  self.wf.nelec*3))
         self.pos.requires_grad = True
 
 
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index d8a4b0ee..d1f2e600 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -1,3 +1,4 @@
+
 import unittest
 import numpy as np
 import torch
@@ -8,9 +9,7 @@
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
@@ -21,7 +20,9 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -29,29 +30,28 @@ 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,
-        )
+            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)
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="auto",
-            include_all_mo=False,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-            backflow=None,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 3c07b012..7f2ac909 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -9,10 +9,7 @@
 
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow import (
-    BackFlowTransformation,
-    BackFlowKernelInverse,
-)
+from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 
 from qmctorch.utils import set_torch_double_precision
 
@@ -21,7 +18,9 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -29,33 +28,33 @@ 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.015',
+            unit='bohr',
+            calculator='pyscf',
+            basis='sto-3g',
+            redo_scf=True)
 
         # define jastrow factor
-        jastrow = JastrowFactor(mol, PadeJastrowKernel)
+        jastrow = JastrowFactor(
+            mol, PadeJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="jacobi",
-            include_all_mo=True,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-            backflow=backflow,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index 3a47cd59..7a40c1b8 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -7,9 +7,7 @@
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
@@ -18,7 +16,9 @@
 
 
 class TestSlaterJastrowCAS(BaseTestCases.WaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -26,29 +26,28 @@ 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,
-        )
+            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)
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="auto",
-            include_all_mo=True,
-            configs="cas(2,2)",
-            jastrow=jastrow,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index 75b0937c..4dc1ffbc 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -8,20 +8,17 @@
 
 from qmctorch.utils import set_torch_double_precision
 
-from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
-    JastrowFactorElectronElectron,
-)
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import (
-    FullyConnectedJastrowKernel,
-    PadeJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel, PadeJastrowKernel
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestSlaterJastrowElectronCusp(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -29,39 +26,38 @@ 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,
-        )
-
-        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
-
-        self.wf = SlaterJastrow(
-            mol,
-            jastrow=jastrow,
-            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))
+        import matplotlib.pyplot as plt
+        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.0, 0.0]) + 1e-6
-        pos_x[:, 1, 0] = 0.0
-        pos_x[:, 1, 1] = 0.0
+        pos_x[:, 0, :] = torch.as_tensor([0., 0., 0.]) + 1E-6
+        pos_x[:, 1, 0] = 0.
+        pos_x[:, 1, 1] = 0.
         pos_x[:, 1, 2] = x
 
-        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[:, 2, :] = 0.5*torch.as_tensor([1., 1., 1.])
+        pos_x[:, 3, :] = -0.5*torch.as_tensor([1., 1., 1.])
 
-        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()
@@ -69,10 +65,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 1a715044..66fbdacf 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -8,17 +8,11 @@
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
-    BackFlowTransformation,
-)
-from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import (
-    BackFlowKernelInverse,
-)
+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
 
@@ -27,7 +21,9 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -35,32 +31,32 @@ 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,
-        )
+            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)
+        jastrow = JastrowFactorElectronElectron(
+            mol, FullyConnectedJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(
+            mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(
-            mol,
-            kinetic="auto",
-            include_all_mo=False,
-            configs="single_double(2,2)",
-            jastrow=jastrow,
-            backflow=None,
-        )
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 443f1419..9072b9c5 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -1,3 +1,5 @@
+
+
 import numpy as np
 import torch
 import unittest
@@ -7,17 +9,11 @@
 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.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.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
 
@@ -25,10 +21,10 @@
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrowOrbitalDependentBackFlow(
-    BaseTestCases.BackFlowWaveFunctionBaseTest
-):
+class TestSlaterJastrowOrbitalDependentBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
+
     def setUp(self):
+
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -36,29 +32,26 @@ 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.015',
+            unit='bohr',
+            calculator='pyscf',
+            basis='sto-3g',
+            redo_scf=True)
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
+        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,
-        )
+            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:
@@ -68,7 +61,8 @@ 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
 
 
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index 3132514e..e50a2ae4 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -10,15 +10,14 @@
 from qmctorch.solver import SolverMPI
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 from qmctorch.utils import set_torch_double_precision
 
 
 class TestH2Hvd(unittest.TestCase):
+
     def setUp(self):
         hvd.init()
 
@@ -33,21 +32,22 @@ 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',
             rank=hvd.local_rank(),
-            mpi_size=hvd.local_size(),
-        )
+            mpi_size=hvd.local_size())
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=False
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='cas(2,2)',
+                                jastrow=jastrow,
+                                cuda=False)
 
         # sampler
         self.sampler = Metropolis(
@@ -56,17 +56,17 @@ def setUp(self):
             step_size=0.2,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("atomic"),
-            move={"type": "all-elec", "proba": "normal"},
-        )
+            init=self.mol.domain('atomic'),
+            move={
+                'type': 'all-elec',
+                'proba': 'normal'})
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverMPI(
-            wf=self.wf, sampler=self.sampler, optimizer=self.opt, rank=hvd.rank()
-        )
+        self.solver = SolverMPI(wf=self.wf, sampler=self.sampler,
+                                                 optimizer=self.opt, rank=hvd.rank())
 
         # ground state energy
         self.ground_state_energy = -1.16
@@ -92,20 +92,17 @@ def test_wf_opt(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.configure(
-            track=["local_energy"],
-            freeze=["ao", "mo"],
-            loss="energy",
-            grad="auto",
-            ortho_mo=False,
-            clip_loss=False,
-            resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-        )
+        self.solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                              loss='energy', grad='auto',
+                              ortho_mo=False, clip_loss=False,
+                              resampling={'mode': 'update',
+                                          'resample_every': 1,
+                                          'nstep_update': 50})
         self.solver.run(10)
 
         MPI.COMM_WORLD.barrier()
 
-        self.solver.wf.load(self.solver.hdf5file, "wf_opt")
+        self.solver.wf.load(self.solver.hdf5file, 'wf_opt')
         self.solver.wf.eval()
 
         obs = self.solver.single_point()

From 725a51fe6352dbec690d65a3b9087226af349d3a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 14:26:52 +0100
Subject: [PATCH 096/286] black only src

---
 qmctorch/__init__.py                          |   5 +-
 qmctorch/__version__.py                       |   2 +-
 qmctorch/sampler/__init__.py                  |  13 +-
 qmctorch/sampler/generalized_metropolis.py    |  77 +++--
 qmctorch/sampler/hamiltonian.py               |  57 ++--
 qmctorch/sampler/metropolis.py                | 147 ++++----
 qmctorch/sampler/metropolis_all_elec.py       | 102 +++---
 .../sampler/metropolis_hasting_all_elec.py    |  79 ++---
 qmctorch/sampler/pints_sampler.py             |  59 ++--
 qmctorch/sampler/proposal_kernels.py          |  15 +-
 qmctorch/sampler/sampler_base.py              |  40 +--
 .../state_dependent_normal_proposal.py        |  18 +-
 qmctorch/sampler/walkers.py                   |  70 ++--
 qmctorch/scf/__init__.py                      |   2 +-
 qmctorch/scf/calculator/__init__.py           |   2 +-
 qmctorch/scf/calculator/adf.py                | 168 ++++-----
 qmctorch/scf/calculator/calculator_base.py    |  21 +-
 qmctorch/scf/calculator/pyscf.py              |  83 +++--
 qmctorch/scf/molecule.py                      | 290 ++++++++--------
 qmctorch/solver/__init__.py                   |   3 +-
 qmctorch/solver/solver.py                     | 184 +++++-----
 qmctorch/solver/solver_base.py                | 316 ++++++++---------
 qmctorch/solver/solver_mpi.py                 | 140 ++++----
 qmctorch/utils/__init__.py                    |  65 ++--
 qmctorch/utils/algebra_utils.py               |  15 +-
 qmctorch/utils/hdf5_utils.py                  | 135 ++++----
 qmctorch/utils/interpolate.py                 | 169 +++++-----
 qmctorch/utils/plot_data.py                   | 108 +++---
 qmctorch/utils/stat_utils.py                  |   8 +-
 qmctorch/utils/torch_utils.py                 |  76 ++---
 qmctorch/wavefunction/__init__.py             |   6 +-
 .../wavefunction/jastrows/combine_jastrow.py  |  73 ++--
 .../distance/electron_electron_distance.py    |  51 ++-
 .../distance/electron_nuclei_distance.py      |  36 +-
 .../wavefunction/jastrows/distance/scaling.py |   4 +-
 .../jastrows/elec_elec/__init__.py            |   4 +-
 .../jastrow_factor_electron_electron.py       |  79 +++--
 .../kernels/fully_connected_jastrow_kernel.py |  53 ++-
 .../jastrow_kernel_electron_electron_base.py  |  15 +-
 .../elec_elec/kernels/pade_jastrow_kernel.py  |  43 ++-
 .../kernels/pade_jastrow_polynomial_kernel.py |  60 ++--
 .../orbital_dependent_jastrow_kernel.py       |  28 +-
 .../jastrows/elec_elec_nuclei/__init__.py     |   4 +-
 ...jastrow_factor_electron_electron_nuclei.py |  89 ++---
 .../elec_elec_nuclei/kernels/__init__.py      |   4 +-
 .../kernels/boys_handy_jastrow_kernel.py      |  15 +-
 .../kernels/fully_connected_jastrow_kernel.py |  11 +-
 ...ow_kernel_electron_electron_nuclei_base.py |  30 +-
 .../jastrow_factor_electron_nuclei.py         |  43 +--
 .../kernels/fully_connected_jastrow_kernel.py |   5 +-
 .../jastrow_kernel_electron_nuclei_base.py    |  15 +-
 .../kernels/pade_jastrow_kernel.py            |  26 +-
 .../jastrows/graph/elec_elec_graph.py         |  10 +-
 .../jastrows/graph/elec_nuc_graph.py          |  26 +-
 .../jastrows/graph/jastrow_graph.py           | 120 +++----
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  |  50 +--
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  45 ++-
 .../jastrows/jastrow_factor_combined_terms.py | 153 +++++----
 .../wavefunction/orbitals/atomic_orbitals.py  | 239 +++++++------
 .../orbitals/atomic_orbitals_backflow.py      |  77 +++--
 ...mic_orbitals_orbital_dependent_backflow.py |  80 +++--
 .../backflow/backflow_transformation.py       | 133 ++++----
 .../backflow_kernel_autodiff_inverse.py       |  10 +-
 .../backflow/kernels/backflow_kernel_base.py  |  17 +-
 .../backflow_kernel_fully_connected.py        |   3 +-
 .../kernels/backflow_kernel_inverse.py        |  12 +-
 .../kernels/backflow_kernel_power_sum.py      |   5 +-
 .../kernels/backflow_kernel_square.py         |   8 +-
 .../orbital_dependent_backflow_kernel.py      |  11 +-
 ...bital_dependent_backflow_transformation.py |  75 ++--
 .../wavefunction/orbitals/norm_orbital.py     |  88 ++---
 .../wavefunction/orbitals/radial_functions.py | 229 +++++++------
 .../orbitals/spherical_harmonics.py           | 319 +++++++++++-------
 .../pooling/orbital_configurations.py         | 132 ++++----
 .../wavefunction/pooling/orbital_projector.py |  89 +++--
 .../wavefunction/pooling/slater_pooling.py    | 283 +++++++++-------
 qmctorch/wavefunction/slater_jastrow.py       | 199 +++++------
 .../slater_orbital_dependent_jastrow.py       |  77 +++--
 .../trash/slater_combined_jastrow.py          |  58 ++--
 .../trash/slater_combined_jastrow_backflow.py | 108 +++---
 qmctorch/wavefunction/trash/slater_jastrow.py |  45 +--
 .../trash/slater_jastrow_backflow.py          |  89 ++---
 .../wavefunction/trash/slater_jastrow_base.py | 164 ++++-----
 .../trash/slater_jastrow_graph.py             |  57 ++--
 qmctorch/wavefunction/wf_base.py              | 113 +++----
 85 files changed, 3223 insertions(+), 3064 deletions(-)

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 1c88fa72..9589dc8c 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -4,12 +4,13 @@
 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"  ____    __  ______________             _")
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 73e3bb4f..f9aa3e11 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = "0.3.2"
diff --git a/qmctorch/sampler/__init__.py b/qmctorch/sampler/__init__.py
index 8b135be4..6a58bffc 100644
--- a/qmctorch/sampler/__init__.py
+++ b/qmctorch/sampler/__init__.py
@@ -1,10 +1,11 @@
 __all__ = [
-    'SamplerBase',
-    'Metropolis',
-    'Hamiltonian',
-    'PintsSampler',
-    'MetropolisHasting',
-    'GeneralizedMetropolis']
+    "SamplerBase",
+    "Metropolis",
+    "Hamiltonian",
+    "PintsSampler",
+    "MetropolisHasting",
+    "GeneralizedMetropolis",
+]
 
 from .sampler_base import SamplerBase
 from .metropolis import Metropolis
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 3a2b53e7..dbf9deef 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -9,12 +9,18 @@
 
 
 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__(
+        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,
+    ):
         """Generalized Metropolis Hasting sampler
 
         Args:
@@ -29,9 +35,9 @@ def __init__(self, nwalkers=100, nstep=1000, step_size=3,
             cuda (bool, optional): use cuda. 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
+        )
 
     def __call__(self, pdf, pos=None, with_tqdm=True):
         """Generate a series of point using MC sampling
@@ -46,7 +52,6 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
             torch.tensor: positions of the walkers
         """
         with torch.no_grad():
-
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
@@ -58,22 +63,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)
@@ -89,17 +95,18 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
                 # 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
 
@@ -117,15 +124,12 @@ def move(self, drift):
 
         # clone and reshape data : Nwlaker, Nelec, Ndim
         new_pos = self.walkers.pos.clone()
-        new_pos = new_pos.view(self.walkers.nwalkers,
-                               self.nelec, self.ndim)
+        new_pos = new_pos.view(self.walkers.nwalkers, self.nelec, self.ndim)
 
         # get indexes
-        index = torch.LongTensor(self.walkers.nwalkers).random_(
-            0, self.nelec)
+        index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
 
-        new_pos[range(self.walkers.nwalkers), index,
-                :] += self._move(drift, index)
+        new_pos[range(self.walkers.nwalkers), index, :] += self._move(drift, index)
 
         return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -140,14 +144,16 @@ def _move(self, drift, index):
             torch.tensor: position of the walkers
         """
 
-        d = drift.view(self.walkers.nwalkers,
-                       self.nelec, self.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))
+        mv = MultivariateNormal(
+            torch.zeros(self.ndim), np.sqrt(self.step_size) * torch.eye(self.ndim)
+        )
 
-        return self.step_size * d[range(self.walkers.nwalkers), index, :] \
+        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
@@ -161,7 +167,7 @@ def trans(self, xf, xi, drifti):
             [type]: [description]
         """
         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):
         """Compute the drift velocity
@@ -174,13 +180,10 @@ 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):
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 22496181..ce592117 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -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,9 +36,9 @@ 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
@@ -99,16 +100,19 @@ 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,8 +122,9 @@ 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
@@ -143,7 +148,7 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = torch.randn(q.shape)
 
         # initial energy terms
-        E_init = U(q) + 0.5 * (p*p).sum(1)
+        E_init = U(q) + 0.5 * (p * p).sum(1)
 
         # half step in momentum space
         p -= 0.5 * epsilon * get_grad(U, q)
@@ -163,11 +168,11 @@ def _step(U, get_grad, epsilon, L, q_init):
         p = -p
 
         # current energy term
-        E_new = U(q) + 0.5 * (p*p).sum(1)
+        E_new = U(q) + 0.5 * (p * p).sum(1)
 
         # 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
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 115b835d..2fda5633 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,19 +8,20 @@
 
 
 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'},
-                 logspace: bool = False,
-                 cuda: bool = False):
+    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"},
+        logspace: bool = False,
+        cuda: bool = False,
+    ):
         """Metropolis Hasting generator
 
         Args:
@@ -51,9 +52,9 @@ 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)
@@ -61,9 +62,8 @@ def __init__(self,
 
     def log_data(self):
         """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):
@@ -77,8 +77,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -93,15 +97,14 @@ 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
 
@@ -114,15 +117,15 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             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)
 
@@ -133,33 +136,36 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                     else:
                         # new function
                         fxn = pdf(Xn)
-                        fxn[fxn == 0.] = eps
+                        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.walkers.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_()
 
@@ -182,28 +188,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:
@@ -219,27 +227,22 @@ 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.walkers.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.walkers.nwalkers).random_(
-                    0, self.nelec)
+                index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
             else:
-                index = torch.LongTensor(
-                    self.walkers.nwalkers).fill_(id_elec)
+                index = torch.LongTensor(self.walkers.nwalkers).fill_(id_elec)
 
             # change selected data
-            new_pos[range(self.walkers.nwalkers), index,
-                    :] += self._move(1)
+            new_pos[range(self.walkers.nwalkers), index, :] += self._move(1)
 
             return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
@@ -252,17 +255,17 @@ 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.walkers.nwalkers, num_elec, self.ndim), device=self.device).view(
-                self.walkers.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)
+            return self.step_size * (2.0 * d - 1.0)
 
-        elif self.movedict['proba'] == 'normal':
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 1a81e923..9184ad7f 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -8,19 +8,20 @@
 
 
 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):
+    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:
@@ -51,26 +52,27 @@ 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.movedict = move
 
-        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.log_data()
 
     def log_data(self):
         """log data about the sampler."""
-        log.info('  Move type           : {0}', 'all-elec')
-        log.info(
-            '  Move proba          : {0}', self.movedict['proba'])
+        log.info("  Move type           : {0}", "all-elec")
+        log.info("  Move proba          : {0}", self.movedict["proba"])
 
     @staticmethod
     def log_func(func):
@@ -84,8 +86,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -105,10 +111,9 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         #     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
 
@@ -121,13 +126,14 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             # 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:
-
                 # new positions
                 Xn = self.move(pdf)
 
@@ -145,26 +151,27 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 index = self._accept(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to('cpu') / \
-                    (self.walkers.nwalkers)
+                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())
+                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_()
 
@@ -189,16 +196,17 @@ 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.walkers.nwalkers, num_elec*self.ndim), device=self.device)
-            return self.step_size * (2. * d - 1.)
+                (self.walkers.nwalkers, num_elec * self.ndim), device=self.device
+            )
+            return self.step_size * (2.0 * d - 1.0)
 
-        elif self.movedict['proba'] == 'normal':
+        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)
+                (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
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index 1934e877..b1473878 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -10,18 +10,19 @@
 
 
 class MetropolisHasting(SamplerBase):
-
-    def __init__(self,
-                 kernel=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):
+    def __init__(
+        self,
+        kernel=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,
+    ):
         """Metropolis Hasting generator
 
         Args:
@@ -52,12 +53,11 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep,
-                             0.0, ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, 0.0, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
-        self.proposal = StateDependentNormalProposal(
-            kernel, nelec, ndim, self.device)
+        self.proposal = StateDependentNormalProposal(kernel, nelec, ndim, self.device)
 
         self.proposal.kernel.nelec = nelec
         self.proposal.kernel.ndim = ndim
@@ -82,8 +82,12 @@ def log_func(func):
         """
         return lambda x: torch.log(func(x))
 
-    def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -97,10 +101,9 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         """
 
         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
 
@@ -109,16 +112,16 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
 
             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:
-
                 # new positions
-                Xn = self.walkers.pos + \
-                    self.proposal(self.walkers.pos)
+                Xn = self.walkers.pos + self.proposal(self.walkers.pos)
 
                 # new function
                 fxn = pdf(Xn)
@@ -127,8 +130,7 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 prob_ratio = fxn / fx
 
                 # get transition ratio
-                trans_ratio = self.proposal.get_transition_ratio(
-                    self.walkers.pos, Xn)
+                trans_ratio = self.proposal.get_transition_ratio(self.walkers.pos, Xn)
 
                 # get the proba
                 df = prob_ratio * trans_ratio
@@ -137,25 +139,26 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
                 index = self.accept_reject(df)
 
                 # acceptance rate
-                rate += index.byte().sum().float().to('cpu') / \
-                    (self.walkers.nwalkers)
+                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())
+                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_()
 
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index fc923f8f..a81c03be 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -7,7 +7,6 @@
 
 
 class torch_model(pints.LogPDF):
-
     def __init__(self, pdf, ndim):
         """Ancillary class tha wrap the wave function in a PINTS class
 
@@ -44,7 +43,7 @@ def evaluateS1(self, x):
         pdf = self.pdf(x)
         log_pdf = torch.log(pdf)
         x.requires_grad = True
-        grad_log_pdf = 1./pdf * self.pdf(x, return_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):
@@ -53,20 +52,21 @@ def n_parameters(self):
 
 
 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):
+    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:
@@ -97,9 +97,9 @@ def __init__(self,
             >>> pos = sampler(wf.pdf)
         """
 
-        SamplerBase.__init__(self, nwalkers, nstep, None,
-                             ntherm, ndecor,
-                             nelec, ndim, init, cuda)
+        SamplerBase.__init__(
+            self, nwalkers, nstep, None, ntherm, ndecor, nelec, ndim, init, cuda
+        )
 
         self.method = method
         self.method_requires_grad = method_requires_grad
@@ -125,8 +125,12 @@ def log_func(func):
 
         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:
+    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:
@@ -140,14 +144,13 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
         """
 
         if self.ntherm >= self.nstep:
-            raise ValueError('Thermalisation longer than trajectory')
+            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
 
@@ -155,12 +158,16 @@ def __call__(self, pdf: Callable, pos: Union[None, torch.Tensor] = None,
             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)
+                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)
+        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
index fd96a120..eaa30c2e 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -8,8 +8,7 @@
 
 
 class DensityVarianceKernel(object):
-
-    def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
+    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
@@ -18,7 +17,7 @@ def __init__(self, atomic_pos, sigma=1., scale_factor=1.):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1. - d).sum(-1)
+        out = self.sigma * (1.0 - d).sum(-1)
         return out.unsqueeze(-1)
 
     def get_atomic_distance(self, pos):
@@ -29,14 +28,12 @@ def get_atomic_distance(self, pos):
 
     def get_estimate_density(self, pos):
         d = self.get_atomic_distance(pos)
-        d = torch.exp(-self.scale_factor*d**2)
+        d = torch.exp(-self.scale_factor * d**2)
         return d
 
 
 class CenterVarianceKernel(object):
-
-    def __init__(self, sigma=1., scale_factor=1.):
-
+    def __init__(self, sigma=1.0, scale_factor=1.0):
         self.sigma = sigma
         self.scale_factor = scale_factor
         self.nelec = None
@@ -44,14 +41,14 @@ def __init__(self, sigma=1., scale_factor=1.):
 
     def __call__(self, x):
         d = self.get_estimate_density(x)
-        out = self.sigma * (1. - d)
+        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)
+        d = torch.exp(-self.scale_factor * d**2)
         return d
 
 
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index b3be0870..f9dd33f6 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -5,10 +5,9 @@
 
 
 class SamplerBase:
-
-    def __init__(self, nwalkers, nstep, step_size,
-                 ntherm, ndecor, nelec, ndim, init,
-                 cuda):
+    def __init__(
+        self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
+    ):
         """Base class for the sampler
 
         Args:
@@ -32,32 +31,35 @@ 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.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'])
+        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, *args, **kwargs):
-        raise NotImplementedError(
-            "Sampler must have a __call__ method")
+        raise NotImplementedError("Sampler must have a __call__ method")
 
     def __repr__(self):
-        return self.__class__.__name__ + ' sampler with  %d walkers' % self.walkers.nwalkers
+        return (
+            self.__class__.__name__
+            + " sampler with  %d walkers" % self.walkers.nwalkers
+        )
 
     def get_sampling_size(self):
         """evaluate the number of sampling point we'll have."""
         if self.ntherm == -1:
             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
index 941a9640..b70a6a2b 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -8,34 +8,30 @@
 
 
 class StateDependentNormalProposal(object):
-
     def __init__(self, kernel, nelec, ndim, device):
-
         self.ndim = ndim
         self.nelec = nelec
         self.kernel = kernel
         self.device = device
         self.multiVariate = MultivariateNormal(
-            torch.zeros(self.ndim), 1. * torch.eye(self.ndim))
+            torch.zeros(self.ndim), 1.0 * torch.eye(self.ndim)
+        )
 
     def __call__(self, x):
         nwalkers = x.shape[0]
         scale = self.kernel(x)
-        displacement = self.multiVariate.sample(
-            (nwalkers, self.nelec)).to(self.device)
+        displacement = self.multiVariate.sample((nwalkers, self.nelec)).to(self.device)
         displacement *= scale
-        return displacement.view(nwalkers, self.nelec*self.ndim)
+        return displacement.view(nwalkers, self.nelec * self.ndim)
 
     def get_transition_ratio(self, x, y):
         sigmax = self.kernel(x)
         sigmay = self.kernel(y)
 
-        rdist = (x-y).view(-1, self.nelec,
-                           self.ndim).norm(dim=-1).unsqueeze(-1)
+        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./sigmay-1./sigmax))
+        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/walkers.py b/qmctorch/sampler/walkers.py
index 4b88fd12..c18411c2 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -6,9 +6,14 @@
 
 
 class Walkers(object):
-
-    def __init__(self, nwalkers: int = 100, nelec: int = 1, ndim: int = 3,
-                 init: Union[Dict, None] = None, cuda: bool = False):
+    def __init__(
+        self,
+        nwalkers: int = 100,
+        nelec: int = 1,
+        ndim: int = 3,
+        init: Union[Dict, None] = None,
+        cuda: bool = False,
+    ):
         """Creates Walkers for the sampler.
 
         Args:
@@ -29,9 +34,9 @@ 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):
         """Initalize the position of the walkers
@@ -44,29 +49,29 @@ 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):
         """Initialize the walkers at the center of the molecule
@@ -74,12 +79,9 @@ def _init_center(self):
         Returns:
             torch.tensor: positions of the walkers
         """
-        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)
+        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):
         """Initialize the walkers in a box covering the molecule
@@ -88,11 +90,9 @@ def _init_uniform(self):
             torch.tensor: positions of the walkers
         """
         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
@@ -101,10 +101,10 @@ def _init_multivar(self):
             torch.tensor -- positions of the walkers
         """
         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"]),
+        )
+        pos = multi.sample((self.nwalkers, self.nelec)).type(torch.get_default_dtype())
         pos = pos.view(self.nwalkers, self.nelec * self.ndim)
         return pos.to(device=self.device)
 
@@ -118,30 +118,26 @@ def _init_atomic(self):
         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 fbd91714..a63d7f72 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -11,40 +11,51 @@
 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__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
-
+    def __init__(
+        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+    ):
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'adf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "adf",
+            savefile,
+        )
 
         # 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):
         """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()
@@ -74,8 +85,8 @@ def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
         bohr2angs = 0.529177
-        scale = 1.
-        if self.units == 'bohr':
+        scale = 1.0
+        if self.units == "bohr":
             scale = bohr2angs
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(scale * np.array(xyz))
@@ -86,30 +97,32 @@ def get_plams_settings(self):
         """Returns 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
@@ -128,46 +141,46 @@ def get_basis_data(self, kffile):
 
         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 = [], [], []
@@ -175,7 +188,6 @@ def get_basis_data(self, kffile):
         basis_bas_exp, basis_bas_norm = [], []
 
         for iat, at in enumerate(atom_type):
-
             number_copy = nqptr[iat + 1] - nqptr[iat]
             idx_bos = list(range(nbptr[iat] - 1, nbptr[iat + 1] - 1))
 
@@ -186,8 +198,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
@@ -203,11 +214,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
@@ -215,12 +225,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
@@ -243,17 +253,17 @@ def read_array(kf, section, name):
         if data.shape == ():
             data = np.array([data])
         return data
-        
-class CalculatorADF2019(CalculatorADF):
 
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
 
+class CalculatorADF2019(CalculatorADF):
+    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, savefile)
+            self, atoms, atom_coords, basis, scf, units, molname, savefile
+        )
 
-        self.adf_version = 'adf2019'
-        self.job_name = ''.join(self.atoms) + '_' + self.basis_name
-        self.output_file = self.job_name + '.t21'
+        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."""
@@ -269,20 +279,20 @@ def get_plams_settings(self):
         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
diff --git a/qmctorch/scf/calculator/calculator_base.py b/qmctorch/scf/calculator/calculator_base.py
index 6ae267ae..007a69a0 100644
--- a/qmctorch/scf/calculator/calculator_base.py
+++ b/qmctorch/scf/calculator/calculator_base.py
@@ -2,8 +2,19 @@
 
 
 class CalculatorBase:
-    def __init__(self, atoms, atom_coords, basis, charge, spin, 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
@@ -16,12 +27,10 @@ def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname,
         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 1e7904fa..06d75fe9 100644
--- a/qmctorch/scf/calculator/pyscf.py
+++ b/qmctorch/scf/calculator/pyscf.py
@@ -8,11 +8,22 @@
 
 
 class CalculatorPySCF(CalculatorBase):
-
-    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
-
+    def __init__(
+        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+    ):
         CalculatorBase.__init__(
-            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, 'pyscf', savefile)
+            self,
+            atoms,
+            atom_coords,
+            basis,
+            charge,
+            spin,
+            scf,
+            units,
+            molname,
+            "pyscf",
+            savefile,
+        )
 
     def run(self):
         """Run the scf calculation using PySCF."""
@@ -26,20 +37,21 @@ def run(self):
             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
 
@@ -55,7 +67,7 @@ def get_basis_data(self, mol, rhf):
         """
 
         # 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]}
@@ -64,9 +76,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
@@ -88,7 +99,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)
 
@@ -104,17 +114,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
@@ -160,15 +169,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)
@@ -196,23 +206,21 @@ def get_basis_data(self, mol, rhf):
         return basis
 
     def get_atoms_str(self):
-        """Refresh the atom string (use after atom move). """
-        atoms_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"]
 
-        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:
@@ -221,10 +229,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 8160b6cf..ba9a07d2 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -13,22 +13,32 @@
 try:
     from mpi4py import MPI
 except ModuleNotFoundError:
-    log.info('  MPI not found.')
+    log.info("  MPI not found.")
 
 
 class Molecule:
-
-    def __init__(self, atom=None, calculator='adf',
-                 scf='hf', basis='dzp', unit='bohr',
-                 charge=0, spin=0,
-                 name=None, load=None, save_scf_file=False,
-                 redo_scf=False, rank=0, mpi_size=0):
+    def __init__(
+        self,
+        atom=None,
+        calculator="adf",
+        scf="hf",
+        basis="dzp",
+        unit="bohr",
+        charge=0,
+        spin=0,
+        name=None,
+        load=None,
+        save_scf_file=False,
+        redo_scf=False,
+        rank=0,
+        mpi_size=0,
+    ):
         """Create a molecule in QMCTorch
 
         Args:
             atom (str or None, optional): defines the atoms and their positions. Defaults to None.
                 - At1 x y z; At2 x y z ... : Provide the atomic coordinate directly
-                - <file>.xyz : provide the path to an .xyz file containing the atomic coordinates 
+                - <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
@@ -75,91 +85,88 @@ def __init__(self, atom=None, calculator='adf',
         self.scf_level = 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.charge,
-                                           self.spin,
-                                           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()
 
             if mpi_size != 0:
-
                 MPI.COMM_WORLD.barrier()
 
                 if rank != 0:
-                    log.info(
-                        '  Loading data from {file}', file=self.hdf5file)
+                    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)
-        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("  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 Energy          : {:.3f} Hartree'.format(self.get_total_energy()))
+            "  SCF Energy          : {:.3f} Hartree".format(self.get_total_energy())
+        )
 
     def domain(self, method):
         """Returns information to initialize the walkers
@@ -178,42 +185,39 @@ 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):
         """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)
 
@@ -228,17 +232,14 @@ 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':
+            if self.unit == "angs":
                 conv2bohr = 1.8897259886
-            self.atom_coords.append(
-                [x * conv2bohr, y * conv2bohr, z * conv2bohr])
+            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
 
@@ -247,11 +248,12 @@ def _get_atomic_properties(self, atoms):
 
         # size of the system
         self.natom = len(self.atoms)
-        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)
+        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:
@@ -264,20 +266,20 @@ def _read_xyz_file(self):
         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 = ''
+        mol_name = ""
         unique_atoms = list(set(atoms))
         for ua in unique_atoms:
             mol_name += ua
@@ -289,48 +291,46 @@ def _get_mol_name(atoms):
     def _load_basis(self):
         """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
@@ -343,31 +343,39 @@ 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):
         """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):
         """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):
         """Load a molecule from hdf5
@@ -377,26 +385,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/solver.py b/qmctorch/solver/solver.py
index 94363fbb..11818411 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -2,18 +2,16 @@
 from time import time
 
 import torch
-from qmctorch.utils import (Loss,
-                            OrthoReg, add_group_attr,
-                            dump_to_hdf5, DataLoader)
+from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 
 from .. import log
 from .solver_base import SolverBase
 
 
 class Solver(SolverBase):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Basic QMC solver
 
         Args:
@@ -24,22 +22,30 @@ 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=None,
+        freeze=None,
+        loss=None,
+        grad=None,
+        ortho_mo=None,
+        clip_loss=False,
+        resampling=None,
+    ):
         """Configure the solver
 
         Args:
@@ -69,8 +75,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,8 +86,7 @@ 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.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
         if ortho_mo is not None:
@@ -99,7 +105,7 @@ 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'):
+        if hasattr(self.wf, "jastrow"):
             for param in self.wf.jastrow.parameters():
                 param.requires_grad = wf_params
 
@@ -117,33 +123,32 @@ 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
 
                 else:
-                    opt_freeze = ['ci', 'mo', 'ao', 'jastrow']
-                    raise ValueError(
-                        'Valid arguments for freeze are :', opt_freeze)
+                    opt_freeze = ["ci", "mo", "ao", "jastrow"]
+                    raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
     def save_sampling_parameters(self, pos):
-        """ save the sampling params."""
+        """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
 
-        if self.resampling_options.mode == 'update':
+        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]
@@ -154,9 +159,17 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.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):
+    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:
@@ -183,31 +196,27 @@ def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
 
         # log data
         self.prepare_optimization(batchsize, None, tqdm)
-        self.log_data_opt(nepoch, 'geometry optimization')
+        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.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.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.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
@@ -228,8 +237,9 @@ def geo_opt(self, nepoch, geo_lr=1e-2, batchsize=None,
 
         return self.observable
 
-    def run(self, nepoch, batchsize=None,
-            hdf5_group='wf_opt', chkpt_every=None, tqdm=False):
+    def run(
+        self, nepoch, batchsize=None, hdf5_group="wf_opt", chkpt_every=None, tqdm=False
+    ):
         """Run a wave function optimization
 
         Args:
@@ -245,7 +255,7 @@ def run(self, nepoch, batchsize=None,
 
         # 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)
@@ -277,8 +287,7 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         self.save_sampling_parameters(pos)
 
         # create the data loader
-        self.dataloader = DataLoader(
-            pos, batch_size=batchsize, pin_memory=self.cuda)
+        self.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
 
         for ibatch, data in enumerate(self.dataloader):
             self.store_observable(data, ibatch=ibatch)
@@ -294,10 +303,9 @@ 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):
         """Run a certain number of epochs
@@ -311,11 +319,11 @@ def run_epochs(self, nepoch):
 
         # loop over the epoch
         for n in range(nepoch):
-
             tstart = time()
-            log.info('')
-            log.info('  epoch %d | %d sampling points' %
-                     (n, len(self.dataloader.dataset)))
+            log.info("")
+            log.info(
+                "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
+            )
 
             cumulative_loss = 0
 
@@ -323,7 +331,6 @@ def run_epochs(self, nepoch):
 
             # loop over the batches
             for ibatch, data in enumerate(self.dataloader):
-
                 # port data to device
                 lpos = data.to(self.device)
 
@@ -333,12 +340,11 @@ 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
 
                 # 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)
@@ -346,8 +352,7 @@ def run_epochs(self, nepoch):
             # 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:
@@ -357,14 +362,13 @@ def run_epochs(self, nepoch):
             self.print_observable(cumulative_loss, verbose=False)
 
             # resample the data
-            self.dataloader.dataset = self.resample(
-                n, self.dataloader.dataset)
+            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))
+            log.info("  epoch done in %1.2f sec." % (time() - tstart))
 
         return cumulative_loss
 
@@ -405,28 +409,26 @@ 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 and wf values
             _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
             psi = self.wf(lpos)
-            norm = 1. / len(psi)
+            norm = 1.0 / len(psi)
 
             # evaluate the prefactor of the grads
             weight = eloc.clone()
             weight -= torch.mean(eloc)
             weight /= psi
-            weight *= 2.
+            weight *= 2.0
             weight *= norm
 
             # compute the gradients
@@ -435,30 +437,22 @@ def evaluate_grad_manual(self, lpos):
             return torch.mean(eloc), eloc
 
         else:
-            raise ValueError(
-                'Manual gradient only for energy minimization')
+            raise ValueError("Manual gradient only for energy minimization")
 
     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 497050c1..ce5c1f41 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -11,10 +11,9 @@
 
 
 class SolverBase:
-
-    def __init__(self, wf=None, sampler=None,
-                 optimizer=None, scheduler=None,
-                 output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Base Class for QMC solver
 
         Args:
@@ -31,7 +30,7 @@ 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("cpu")
 
         # member defined in the child and or method
         self.dataloader = None
@@ -39,33 +38,38 @@ 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 = "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
         if output is None:
-            basename = os.path.basename(
-                self.wf.mol.hdf5file).split('.')[0]
-            self.hdf5file = basename + '_QMCTorch.hdf5'
+            basename = os.path.basename(self.wf.mol.hdf5file).split(".")[0]
+            self.hdf5file = basename + "_QMCTorch.hdf5"
 
         if rank == 0:
             dump_to_hdf5(self, self.hdf5file)
 
         self.log_data()
 
-    def configure_resampling(self, mode='update', resample_every=1, nstep_update=25, ntherm_update=-1,
-                             increment={'every': None, 'factor': None}):
+    def configure_resampling(
+        self,
+        mode="update",
+        resample_every=1,
+        nstep_update=25,
+        ntherm_update=-1,
+        increment={"every": None, "factor": None},
+    ):
         """Configure the resampling
 
         Args:
@@ -84,10 +88,9 @@ def configure_resampling(self, mode='update', resample_every=1, nstep_update=25,
         """
 
         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
@@ -108,47 +111,47 @@ 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()
 
         # 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()):
                     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()):
                     if p.requires_grad:
-                        self.observable.__setattr__(key+'.grad', [])
+                        self.observable.__setattr__(key + ".grad", [])
 
             else:
                 self.observable.__setattr__(k, [])
@@ -166,50 +169,49 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
             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':
-
+            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).item())
+                    self.observable.energy.append(np.mean(data).item())
                 else:
-                    self.observable.energy[-1] *= ibatch/(ibatch+1)
-                    self.observable.energy[-1] += np.mean(
-                        data).item()/(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):
@@ -220,12 +222,11 @@ 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):
         """Print the observalbe to csreen
@@ -236,23 +237,19 @@ 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):
         """Resample the wave function
@@ -265,39 +262,39 @@ 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()[
-                           :self.sampler.walkers.nwalkers]).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
+                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)
+                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, batchsize=None, hdf5_group='single_point'):
+    def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"):
         """Performs a single point calculatin
 
         Args:
@@ -309,21 +306,22 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'
             SimpleNamespace: contains the local energy, positions, ...
         """
 
-        log.info('')
-        log.info('  Single Point Calculation : {nw} walkers | {ns} steps',
-                 nw=self.sampler.walkers.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:
-
             #  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':
+            pos = 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
@@ -331,40 +329,32 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group='single_point'
                 eloc = self.wf.local_energy(pos)
 
             else:
-                nbatch = int(np.ceil(len(pos)/batchsize))
+                nbatch = int(np.ceil(len(pos) / batchsize))
 
                 for ibatch in range(nbatch):
                     istart = ibatch * batchsize
-                    iend = min((ibatch+1) * batchsize, len(pos))
+                    iend = min((ibatch + 1) * batchsize, len(pos))
                     if ibatch == 0:
-                        eloc = self.wf.local_energy(
-                            pos[istart:iend, :])
+                        eloc = self.wf.local_energy(pos[istart:iend, :])
                     else:
-                        eloc = torch.cat((eloc, self.wf.local_energy(
-                            pos[istart:iend, :])))
+                        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)
+            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())
 
             # dump data to hdf5
             obs = SimpleNamespace(
-                pos=pos,
-                local_energy=eloc,
-                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
 
@@ -376,13 +366,16 @@ def save_checkpoint(self, epoch, loss):
             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)
+        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):
         """load a model/optmizer
@@ -394,10 +387,10 @@ 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):
@@ -412,7 +405,7 @@ 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=None, with_tqdm=True, hdf5_group="sampling_trajectory"):
         """Compute the local energy along a sampling trajectory
 
         Args:
@@ -422,8 +415,8 @@ 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)
@@ -431,18 +424,15 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group='sampling_trajector
         ndim = pos.shape[-1]
         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:
             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):
@@ -476,52 +466,46 @@ def save_traj(self, fname, obs):
         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, batchsize=None, loss="variance"):
         raise NotImplementedError()
 
     def log_data(self):
         """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 fdf994c9..7562bc4d 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -2,8 +2,7 @@
 from types import SimpleNamespace
 
 import torch
-from qmctorch.utils import (DataLoader, Loss, OrthoReg, add_group_attr,
-                            dump_to_hdf5)
+from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
 
 from .. import log
 from .solver import Solver
@@ -20,9 +19,9 @@ def logd(rank, *args):
 
 
 class SolverMPI(Solver):
-
-    def __init__(self, wf=None, sampler=None, optimizer=None,
-                 scheduler=None, output=None, rank=0):
+    def __init__(
+        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
+    ):
         """Distributed QMC solver
 
         Args:
@@ -34,18 +33,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.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(
+        self,
+        nepoch,
+        batchsize=None,
+        loss="energy",
+        clip_loss=False,
+        grad="manual",
+        hdf5_group="wf_opt",
+        num_threads=1,
+        chkpt_every=None,
+    ):
         """Run the optimization
 
         Args:
@@ -63,21 +70,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.walkers.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()
@@ -87,8 +100,7 @@ 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)
+        self.loss.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
         self.ortho_loss = OrthoReg()
@@ -96,7 +108,7 @@ def run(self, nepoch, batchsize=None, loss='energy',
         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:
@@ -119,27 +131,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]
 
         # create the data loader
         # self.dataset = DataSet(pos)
-        self.dataloader = DataLoader(
-            pos, batch_size=batchsize, pin_memory=self.cuda)
-        min_loss = 1E3
+        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
@@ -153,16 +162,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:
@@ -179,8 +185,7 @@ 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
@@ -189,11 +194,11 @@ def run(self, nepoch, batchsize=None, loss='energy',
 
         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=True, hdf5_group="single_point"):
         """Performs a single point calculation
 
         Args:
@@ -205,13 +210,17 @@ 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.walkers.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
+            ),
+        )
 
         # 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
@@ -220,46 +229,39 @@ 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':
+            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)
+            e, s, err = torch.mean(eloc), torch.var(eloc), 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 = hvd.allgather(eloc, name="local_energies")
+            e, s, err = (
+                torch.mean(eloc_all),
+                torch.var(eloc_all),
+                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
+                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
 
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 67e0052b..10f8e555 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -1,10 +1,14 @@
 """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 .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,
@@ -12,25 +16,44 @@
 #                         plot_integrated_autocorrelation_time,
 #                         plot_walkers_traj)
 
-from .stat_utils import (blocking, correlation_coefficient,
-                         integrated_autocorrelation_time)
-from .torch_utils import (DataSet, DataLoader, Loss, OrthoReg, fast_power,
-                          set_torch_double_precision,
-                          set_torch_single_precision,
-                          diagonal_hessian, gradients)
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    integrated_autocorrelation_time,
+)
+from .torch_utils import (
+    DataSet,
+    DataLoader,
+    Loss,
+    OrthoReg,
+    fast_power,
+    set_torch_double_precision,
+    set_torch_single_precision,
+    diagonal_hessian,
+    gradients,
+)
 
 # __all__ = ['plot_energy', 'plot_data', 'plot_block',
 #            'plot_walkers_traj',
 #            'plot_correlation_time',
 #            'plot_autocorrelation',
-__all__ = ['set_torch_double_precision',
-           'set_torch_single_precision',
-           'DataSet', 'Loss', 'OrthoReg', 'DataLoader',
-           'dump_to_hdf5', 'load_from_hdf5',
-           'bytes2str',
-           'register_extra_attributes',
-           'fast_power',
-           'InterpolateMolecularOrbitals',
-           'InterpolateAtomicOrbitals',
-           'btrace', 'bdet2', 'bproj',
-           'diagonal_hessian', 'gradients']
+__all__ = [
+    "set_torch_double_precision",
+    "set_torch_single_precision",
+    "DataSet",
+    "Loss",
+    "OrthoReg",
+    "DataLoader",
+    "dump_to_hdf5",
+    "load_from_hdf5",
+    "bytes2str",
+    "register_extra_attributes",
+    "fast_power",
+    "InterpolateMolecularOrbitals",
+    "InterpolateAtomicOrbitals",
+    "btrace",
+    "bdet2",
+    "bproj",
+    "diagonal_hessian",
+    "gradients",
+]
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index 50f5d5bf..a87c7be6 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -44,33 +44,34 @@ def bdet2(M):
 
 
 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)
 
         # 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/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index cff485a3..4ce2dc54 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -9,16 +9,19 @@
 
 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 +33,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 +50,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,12 +66,8 @@ 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)
+            parent_obj.__setattr__(grp_name, SimpleNamespace())
+        load_object(grp, parent_obj.__getattribute__(grp_name), grp_name)
     except:
         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)
 
@@ -314,8 +314,7 @@ def insert_tuple(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
     # fix for type torch.Tensor
-    obj = [o.numpy() if isinstance(
-        o, torch.Tensor) else o for o in obj]
+    obj = [o.numpy() if isinstance(o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 
@@ -327,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)
 
 
@@ -378,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):
@@ -391,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()
 
 
@@ -408,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))
@@ -434,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)
 
@@ -465,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()
@@ -478,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..9f19d833 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -8,22 +8,21 @@
 # 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):
-
-        if method == 'irreg':
-            n = kwargs['n'] if 'n' in kwargs else 6
+    def __call__(self, pos, method="irreg", orb="occupied", **kwargs):
+        if method == "irreg":
+            n = kwargs["n"] if "n" in kwargs else 6
             return self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
 
-        elif method == 'reg':
-            rstr, bstr = 'resolution', 'border_length'
+        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.
+            blength = kwargs[bstr] if bstr in kwargs else 2.0
             return self.interpolate_mo_reg_grid(pos, res, blength, orb)
 
     def get_mo_max_index(self, orb):
@@ -36,14 +35,12 @@ def get_mo_max_index(self, orb):
             ValueError: if orb not valid
         """
 
-        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.
@@ -57,26 +54,25 @@ def interpolate_mo_irreg_grid(self, pos, n, orb):
         """
         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):
                 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()
+                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, res, blength, orb):
         """Interpolate the mo occupied in the configs.
 
         Args:
@@ -88,29 +84,26 @@ 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]
+                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
@@ -127,22 +120,30 @@ def __call__(self, pos, n=6, length=2):
             torch.tensor: Interpolated values
         """
 
-        if not hasattr(self, 'interp_func'):
+        if not hasattr(self, "interp_func"):
             t0 = time()
             self.get_interpolator()
-            print('___', time()-t0)
+            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))
 
@@ -157,37 +158,42 @@ def get_interpolator(self, n=6, length=2):
         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):
             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)]
+        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, border_length=2.):
+def get_boundaries(atomic_positions, border_length=2.0):
     """Computes the boundaries of the structure
 
     Args:
@@ -213,7 +219,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,7 +228,7 @@ 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, resolution=0.1, border_length=2.0):
     """Computes a regular grid points from the atomic positions
 
     Args:
@@ -233,9 +240,8 @@ def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.):
         (np.ndarray, np.ndarray, mp.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])
@@ -257,16 +263,13 @@ def interpolator_reg_grid(func, x, y, z):
         callable: 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):
@@ -280,32 +283,31 @@ 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
+    return x // 2 * 2 == x
 
 
 def logspace(n, length):
     """returns a 1d array of logspace between -length and +length."""
-    k = np.log(length+1)/np.log(10)
+    k = np.log(length + 1) / np.log(10)
     if is_even(n):
-        x = np.logspace(0.01, k, n//2)-1
+        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.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, n=6, length=2.0, border_length=2.0):
     """Computes a logarithmic grid
 
     Args:
@@ -318,14 +320,11 @@ def get_log_grid(atomic_positions, n=6, length=2., border_length=2.):
         np.ndanrray: 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
@@ -347,9 +346,7 @@ def interpolator_irreg_grid(func, grid_pts):
         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):
@@ -363,5 +360,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
+    nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
     return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim)))
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 18d70ec8..10f3b61a 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -2,9 +2,12 @@
 import numpy as np
 from matplotlib import cm
 
-from .stat_utils import (blocking, correlation_coefficient,
-                         fit_correlation_coefficient,
-                         integrated_autocorrelation_time)
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    fit_correlation_coefficient,
+    integrated_autocorrelation_time,
+)
 
 
 def plot_energy(local_energy, e0=None, show_variance=False):
@@ -27,21 +30,22 @@ def plot_energy(local_energy, e0=None, show_variance=False):
     variance = np.array([np.var(e) 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, energy - variance, energy + variance, 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()
@@ -60,12 +64,12 @@ 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, walkers="mean"):
     """Plot the trajectory of all the individual walkers
 
     Args:
@@ -77,28 +81,26 @@ def plot_walkers_traj(eloc, walkers='mean'):
     celoc /= np.arange(1, nstep + 1)
 
     if walkers is not None:
-
-        if walkers == 'all':
-            plt.plot(eloc, 'o', alpha=max(
-                1 / nwalkers, 1E-2), 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()
 
@@ -116,18 +118,18 @@ def plot_correlation_coefficient(eloc, size_max=100):
     """
 
     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()
 
@@ -152,11 +154,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,23 +164,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, block_size, walkers="mean"):
     """Plot the blocked energy values
 
     Args:
@@ -192,24 +192,24 @@ def plot_blocking_energy(eloc, block_size, walkers='mean'):
         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)
@@ -233,8 +233,8 @@ 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()
 
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 11c2dc3d..38f2e4bc 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -13,7 +13,7 @@ def blocking(x, block_size, expand=False):
     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:
@@ -33,7 +33,7 @@ def correlation_coefficient(x, norm=True):
     N = x.shape[0]
     xm = x - x.mean(0)
 
-    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1:]
+    c = fftconvolve(xm, xm[::-1], axes=0)[N - 1 :]
 
     if norm:
         c /= c[0]
@@ -48,7 +48,7 @@ def integrated_autocorrelation_time(correlation_coeff, size_max):
         correlation_coeff (np.ndarray): coeff size Nsample,Nexp
         size_max (int): max size
     """
-    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):
@@ -68,7 +68,7 @@ def fit_exp(x, y):
         def func(x, tau):
             return np.exp(-x / tau)
 
-        popt, pcov = curve_fit(func, x, y, p0=(1.))
+        popt, pcov = 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 b61c0d56..4050eeff 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -31,7 +31,6 @@ def fast_power(x, k, mask0=None, mask2=None):
     """
     kmax = 3
     if k.max() < kmax:
-
         out = x.clone()
 
         if mask0 is None:
@@ -72,10 +71,7 @@ def diagonal_hessian(out, inp, return_grads=False):
     """
     # 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()
@@ -85,11 +81,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]
 
@@ -101,7 +95,6 @@ def diagonal_hessian(out, inp, return_grads=False):
 
 
 class DataSet(Dataset):
-
     def __init__(self, data):
         """Creates a torch data set
 
@@ -130,8 +123,7 @@ def __getitem__(self, index):
         return self.data[index, :]
 
 
-class DataLoader():
-
+class DataLoader:
     def __init__(self, data, batch_size, pin_memory=False):
         """Simple DataLoader to replace toch data loader
 
@@ -147,7 +139,7 @@ def __init__(self, data, batch_size, pin_memory=False):
             self.dataset = data
 
         self.len = len(data)
-        self.nbatch = ceil(self.len/batch_size)
+        self.nbatch = ceil(self.len / batch_size)
         self.count = 0
         self.batch_size = batch_size
 
@@ -156,13 +148,14 @@ def __iter__(self):
         return self
 
     def __next__(self):
-        if self.count < self.nbatch-1:
-            out = self.dataset[self.count *
-                               self.batch_size:(self.count+1)*self.batch_size]
+        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:]
+        elif self.count == self.nbatch - 1:
+            out = self.dataset[self.count * self.batch_size :]
             self.count += 1
             return out
         else:
@@ -170,12 +163,7 @@ def __next__(self):
 
 
 class Loss(nn.Module):
-
-    def __init__(
-            self,
-            wf,
-            method='energy',
-            clip=False):
+    def __init__(self, wf, method="energy", clip=False):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -205,11 +193,10 @@ def __init__(
         self.clip_num_std = 5
 
         # select loss function
-        self.loss_fn = {'energy': torch.mean,
-                        'variance': torch.var}[method]
+        self.loss_fn = {"energy": torch.mean, "variance": torch.var}[method]
 
         # init values of the weights
-        self.weight = {'psi': None, 'psi0': None}
+        self.weight = {"psi": None, "psi0": None}
 
     def forward(self, pos, no_grad=False, deactivate_weight=False):
         """Computes the loss
@@ -227,7 +214,6 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
 
         # check if grads are requested
         with self.get_grad_mode(no_grad):
-
             # compute local eneergies
             local_energies = self.wf.local_energy(pos)
 
@@ -263,47 +249,41 @@ def get_clipping_mask(self, 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)
+            mask = (local_energies < emax) & (local_energies > emin)
         else:
-            mask = torch.ones_like(
-                local_energies).type(torch.bool)
+            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
+        done at every step
         """
 
-        local_use_weight = self.use_weight * \
-            (not deactivate_weight)
+        local_use_weight = self.use_weight * (not deactivate_weight)
 
         if local_use_weight:
-
             # computes the weights
-            self.weight['psi'] = self.wf(pos)
+            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'])
+            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 = (self.weight["psi"] / self.weight["psi0"]) ** 2
                 w /= w.sum()  # should we multiply by the number of elements ?
 
             return w
 
         else:
-            return 1.
+            return 1.0
 
 
 class OrthoReg(nn.Module):
-    '''add a penalty to make matrice orthgonal.'''
+    """add a penalty to make matrice orthgonal."""
 
     def __init__(self, alpha=0.1):
         """Add a penalty loss to keep the MO orthogonalized
@@ -316,6 +296,4 @@ def __init__(self, alpha=0.1):
 
     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]))
+        return self.alpha * torch.norm(W.mm(W.transpose(0, 1)) - torch.eye(W.shape[0]))
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 6d4e27de..6078939e 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,11 +1,13 @@
-__all__ = ['WaveFunction', 'SlaterJastrow']
+__all__ = ["WaveFunction", "SlaterJastrow"]
 
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
-__all__ = ['WaveFunction', 'SlaterJastrow', 'SlaterOrbitalDependentJastrow']
+
+__all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
 
 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
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 90bac67e..70fd8ee3 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,11 +1,9 @@
-
 import torch
 from torch import nn
 from functools import reduce
 
 
 class CombineJastrow(nn.Module):
-
     def __init__(self, jastrow):
         """[summary]
 
@@ -53,69 +51,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:
@@ -125,15 +121,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:
@@ -144,25 +140,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/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 3b6fbd3a..9c8a776a 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -1,12 +1,13 @@
 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):
         """Computes the electron-electron distances
 
@@ -36,9 +37,9 @@ 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):
         """Compute the pairwise distance between the electrons
@@ -79,7 +80,6 @@ def forward(self, input, derivative=0):
                 return dist
 
         elif derivative == 1:
-
             der_dist = self.get_der_distance(input_, dist)
 
             if self.scale:
@@ -88,15 +88,13 @@ 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
 
@@ -113,14 +111,11 @@ 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_)
@@ -143,11 +138,9 @@ 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
@@ -168,16 +161,13 @@ 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):
@@ -191,8 +181,7 @@ 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
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index ea4a67f4..bba5e66b 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,12 +1,13 @@
 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 ElectronNucleiDistance(nn.Module):
-
     def __init__(self, nelec, atomic_pos, ndim=3, scale=False, scale_factor=0.6):
         """Computes the electron-nuclei distances
 
@@ -67,21 +68,18 @@ 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
 
@@ -101,9 +99,8 @@ 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):
@@ -121,14 +118,13 @@ 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):
@@ -142,5 +138,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..070b6f32 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -16,7 +16,7 @@ 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):
@@ -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 3c165029..98540879 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -1,4 +1,6 @@
-from .jastrow_factor_electron_electron import JastrowFactorElectronElectron as JastrowFactor
+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
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 6b121115..d88d7f1a 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -5,14 +5,17 @@
 
 
 class JastrowFactorElectronElectron(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 orbital_dependent_kernel=False,
-                 number_of_orbitals=None,
-                 scale=False, scale_factor=0.6,
-                 cuda=False):
+    def __init__(
+        self,
+        mol,
+        jastrow_kernel,
+        kernel_kwargs={},
+        orbital_dependent_kernel=False,
+        number_of_orbitals=None,
+        scale=False,
+        scale_factor=0.6,
+        cuda=False,
+    ):
         """Electron-Electron Jastrow factor.
 
         .. math::
@@ -38,28 +41,35 @@ def __init__(self, mol,
         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:
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
-                mol.nup, mol.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(
-                mol.nup, mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -71,11 +81,10 @@ def get_mask_tri_up(self):
         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
@@ -112,13 +121,15 @@ 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)
+            return self.extract_tri_up(self.edist(pos, derivative=2)).view(
+                nbatch, 3, -1
+            )
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -156,21 +167,20 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -188,9 +198,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
@@ -200,9 +208,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
@@ -228,8 +234,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]
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..b9407339 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
@@ -5,11 +5,16 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self,  nup, ndown, cuda,
-                 size1=16, size2=8,
-                 activation=torch.nn.Sigmoid(),
-                 include_cusp_weight=True):
+    def __init__(
+        self,
+        nup,
+        ndown,
+        cuda,
+        size1=16,
+        size2=8,
+        activation=torch.nn.Sigmoid(),
+        include_cusp_weight=True,
+    ):
         """Defines a fully connected jastrow factors."""
 
         super().__init__(nup, ndown, cuda)
@@ -20,13 +25,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)
 
@@ -41,13 +46,12 @@ def get_var_weight(self):
 
         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:
@@ -63,16 +67,29 @@ def get_static_weight(self):
             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
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..7203719d 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
@@ -5,7 +5,6 @@
 
 
 class JastrowKernelElectronElectronBase(nn.Module):
-
     def __init__(self, nup, ndown, cuda, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
 
@@ -18,9 +17,9 @@ 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
 
@@ -71,7 +70,6 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -101,12 +99,10 @@ 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
 
@@ -134,10 +130,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..eddeeffd 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, ndown, cuda, w=1.0):
         """Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -26,9 +25,8 @@ 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
@@ -40,22 +38,35 @@ def get_static_weight(self):
             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.
+        """Get the jastrow kernel.
 
         .. math::
             B_{ij} = \\frac{w_0 r_{i,j}}{1+w r_{i,j}}
@@ -99,11 +110,11 @@ 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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -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..e3f8bb93 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
@@ -6,11 +6,7 @@
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-
-    def __init__(self, nup, ndown, cuda,
-                 order=2,
-                 weight_a=None,
-                 weight_b=None):
+    def __init__(self, nup, ndown, cuda, order=2, weight_a=None, weight_b=None):
         """Computes a polynomial Pade-Jastrow factor
 
         .. math::
@@ -51,16 +47,29 @@ def get_static_weight(self):
             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
@@ -75,7 +84,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 +97,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.
+        """Get the jastrow kernel.
 
         .. math::
 
@@ -191,12 +200,13 @@ 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
 
@@ -213,7 +223,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):
@@ -245,7 +255,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
@@ -277,10 +286,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 bbb814b9..8c4b6053 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -1,3 +1,5 @@
-from .jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei as JastrowFactor
+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
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 2a5482bd..3d296aa5 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
@@ -8,11 +8,7 @@
 
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -34,9 +30,9 @@ def __init__(self, mol,
         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)
@@ -44,24 +40,20 @@ def __init__(self, mol,
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(mol.nup, mol.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
@@ -77,11 +69,10 @@ def get_mask_tri_up(self):
         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
@@ -121,8 +112,7 @@ 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):
         """Assemle the different distances for easy calculations
@@ -177,9 +167,9 @@ def assemble_dist_deriv(self, pos, derivative=1):
     def _to_device(self):
         """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)
@@ -221,9 +211,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)
@@ -232,23 +223,21 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -264,7 +253,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)
@@ -289,7 +277,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)
@@ -297,8 +284,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]
@@ -330,8 +316,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])
@@ -375,7 +360,7 @@ 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):
         """Compute the second derivative of the jastrow factor automatically.
@@ -387,24 +372,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..7810c835 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -1,3 +1,5 @@
 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
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..96111e7d 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,10 +1,11 @@
 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.
 
@@ -60,15 +61,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..ad0ed97c 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,9 +1,10 @@
 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, ndown, atomic_pos, cuda):
         """Defines a fully connected jastrow factors."""
 
@@ -17,9 +18,9 @@ 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()
 
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..b2042712 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,7 +5,6 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
-
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base Class for the elec-elec-nuc jastrow kernel
 
@@ -26,9 +25,9 @@ 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):
@@ -58,16 +57,14 @@ def compute_derivative(self, r, dr):
         return out
 
     def compute_second_derivative(self, r, dr, d2r):
-        """Get the elements of the pure 2nd derivative of the jastrow kernels.
-        """
+        """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
 
@@ -92,20 +89,19 @@ def _hess(val, pos, device):
             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/jastrow_factor_electron_nuclei.py b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
index 1bae2032..b376d6ad 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -4,11 +4,7 @@
 
 
 class JastrowFactorElectronNuclei(nn.Module):
-
-    def __init__(self, mol,
-                 jastrow_kernel,
-                 kernel_kwargs={},
-                 cuda=False):
+    def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         r"""Base class for two el-nuc jastrow of the form:
 
         .. math::
@@ -28,9 +24,9 @@ def __init__(self, mol,
         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)
@@ -38,16 +34,15 @@ def __init__(self, mol,
         self.ndim = 3
 
         # kernel function
-        self.jastrow_kernel = jastrow_kernel(mol.nup,  mol.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 __repr__(self):
         """representation of the jastrow factor"""
@@ -89,21 +84,20 @@ 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):
         """Compute the value of the derivative of the Jastrow factor
@@ -119,14 +113,10 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
         """
         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):
@@ -144,12 +134,11 @@ def jastrow_factor_second_derivative(self, r, dr, d2r, jast):
         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/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/fully_connected_jastrow_kernel.py
index beefdc28..d9e5bd69 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,8 +5,7 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
-
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
+    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
         r"""Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -31,7 +30,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.):
         self.requires_autograd = True
 
     def forward(self, x):
-        """ Get the jastrow kernel.
+        """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..d0890f3e 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
@@ -4,7 +4,6 @@
 
 
 class JastrowKernelElectronNucleiBase(nn.Module):
-
     def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
         r"""Base class for the elec-nuc jastrow factor
 
@@ -27,9 +26,9 @@ 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):
@@ -73,7 +72,6 @@ def compute_derivative(self, r, dr):
             r.requires_grad = True
 
         with torch.enable_grad():
-
             kernel = self.forward(r)
             ker_grad = self._grads(kernel, r)
 
@@ -108,13 +106,11 @@ 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
 
@@ -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..ca0b4159 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, ndown, atomic_pos, cuda, w=1.0):
         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.
+        """Get the jastrow kernel.
         .. math::
             B_{ij} = \frac{b r_{i,j}}{1+b'r_{i,j}}
 
@@ -70,11 +70,11 @@ 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):
         """Get the elements of the pure 2nd derivative of the jastrow kernels
@@ -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/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 88be8258..35a8f7f9 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -19,11 +19,10 @@ def ElecElecGraph(nelec, nup):
 
 
 def get_elec_elec_edges(nelec):
-    """Compute the edge index of the electron-electron graph.
-    """
+    """Compute the edge index of the electron-electron graph."""
     ee_edges = ([], [])
-    for i in range(nelec-1):
-        for j in range(i+1, nelec):
+    for i in range(nelec - 1):
+        for j in range(i + 1, nelec):
             ee_edges[0].append(i)
             ee_edges[1].append(j)
 
@@ -34,8 +33,7 @@ def get_elec_elec_edges(nelec):
 
 
 def get_elec_elec_ndata(nelec, nup):
-    """Compute the node data of the elec-elec graph
-    """
+    """Compute the node data of the elec-elec graph"""
 
     ee_ndata = []
     for i in range(nelec):
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 0d6f0f72..0cb22dc8 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -16,21 +16,20 @@ def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
     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)
+        natoms, atom_types, atomic_features, nelec, nup
+    )
     return graph
 
 
 def get_elec_nuc_edges(natoms, nelec):
-    """Compute the edge index of the electron-nuclei graph.
-    """
+    """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[1].append(natoms + j)
 
-            en_edges[0].append(natoms+j)
+            en_edges[0].append(natoms + j)
             en_edges[1].append(i)
 
     # for i in range(natoms-1):
@@ -40,9 +39,8 @@ def get_elec_nuc_edges(natoms, nelec):
     return en_edges
 
 
-def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
-    """Compute the node data of the elec-elec graph
-    """
+def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
+    """Compute the node data of the elec-elec graph"""
 
     en_ndata = []
     embed_number = 0
@@ -65,22 +63,20 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features,  nelec, nup):
         if i < nup:
             en_ndata.append(embed_number)
         else:
-            en_ndata.append(embed_number+1)
+            en_ndata.append(embed_number + 1)
 
     return torch.LongTensor(en_ndata)
 
 
 def get_atomic_features(atom_type, atomic_features):
-    """Get the atomic features requested.
-    """
+    """Get the atomic features requested."""
     if atom_type is not None:
         data = element(atom_type)
-        feat = [getattr(data, feat)
-                for feat in atomic_features]
+        feat = [getattr(data, feat) for feat in atomic_features]
     else:
         feat = []
         for atf in atomic_features:
-            if atf == 'atomic_number':
+            if atf == "atomic_number":
                 feat.append(-1)
             else:
                 feat.append(0)
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
index e74a5a9d..a2c409c1 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -11,14 +11,16 @@
 
 
 class JastrowFactorGraph(nn.Module):
-
-    def __init__(self, mol,
-                 ee_model=MGCNPredictor,
-                 ee_model_kwargs={},
-                 en_model=MGCNPredictor,
-                 en_model_kwargs={},
-                 atomic_features=["atomic_number"],
-                 cuda=False):
+    def __init__(
+        self,
+        mol,
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+    ):
         """Graph Neural Network Jastrow Factor
 
         Args:
@@ -42,14 +44,13 @@ def __init__(self, mol,
         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.atom_types = mol.atoms
         self.atomic_features = atomic_features
-        self.atoms = torch.as_tensor(
-            mol.atom_coords).to(self.device)
+        self.atoms = torch.as_tensor(mol.atom_coords).to(self.device)
         self.natoms = self.atoms.shape[0]
 
         self.requires_autograd = True
@@ -58,10 +59,8 @@ def __init__(self, mol,
         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)
+        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
@@ -70,15 +69,16 @@ def __init__(self, mol,
 
         # instantiate the en model
         en_model_kwargs["num_node_types"] = 2 + self.natoms
-        en_model_kwargs["num_edge_types"] = 2*self.natoms
+        en_model_kwargs["num_edge_types"] = 2 * self.natoms
         self.en_model = en_model(**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)
+        self.en_graph = ElecNucGraph(
+            self.natoms, self.atom_types, self.atomic_features, self.nelec, self.nup
+        )
 
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
@@ -105,8 +105,8 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -115,22 +115,16 @@ def forward(self, pos, derivative=0, sum_grad=True):
         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)
+        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)
@@ -142,7 +136,9 @@ def forward(self, pos, derivative=0, sum_grad=True):
             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)
+            return self._get_hess_vals(
+                pos, ee_kernel, en_kernel, sum_grad=sum_grad, return_all=True
+            )
 
     def _get_val(self, ee_kernel, en_kernel):
         """Get the jastrow values.
@@ -166,18 +162,19 @@ def _get_grad_vals(self, pos, ee_kernel, en_kernel, sum_grad):
 
         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)
+        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, ee_kernel, en_kernel, sum_grad=False, return_all=False):
+    def _get_hess_vals(
+        self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=False
+    ):
         """Get the hessian values
 
         Args:
@@ -192,10 +189,13 @@ def _get_hess_vals(self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=F
 
         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]
+        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)
@@ -203,18 +203,19 @@ def _get_hess_vals(self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=F
         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]
+            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)
+        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)
+            grad_val = grad_val.detach().reshape(nbatch, self.nelec, 3).transpose(1, 2)
 
             if sum_grad:
                 grad_val = grad_val.sum(1)
@@ -230,11 +231,10 @@ def get_mask_tri_up(self):
         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
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
index 018030bf..871927d6 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -57,11 +57,11 @@ def get_edge_types(self, edges):
         dict
             Mapping 'type' to the computed edge types.
         """
-        node_type1 = edges.src['type']
-        node_type2 = edges.dst['type']
+        node_type1 = edges.src["type"]
+        node_type2 = edges.dst["type"]
         return {
-            'type': node_type1 * node_type2 +
-            (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+            "type": node_type1 * node_type2
+            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
         }
 
     def forward(self, g, node_types):
@@ -80,9 +80,9 @@ def forward(self, g, node_types):
             Edge representations.
         """
         g = g.local_var()
-        g.ndata['type'] = node_types
+        g.ndata["type"] = node_types
         g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata['type'])
+        return self.embed(g.edata["type"])
 
 
 class VEConv(nn.Module):
@@ -109,7 +109,7 @@ def __init__(self, dist_feats, feats, update_edge=True):
         self.update_dists = nn.Sequential(
             nn.Linear(dist_feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats)
+            nn.Linear(feats, feats),
         )
         if update_edge:
             self.update_edge_feats = nn.Linear(feats, feats)
@@ -151,12 +151,11 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
             edge_feats = self.update_edge_feats(edge_feats)
 
         g = g.local_var()
-        g.ndata.update({'hv': node_feats})
-        g.edata.update({'dist': expanded_dists, 'he': edge_feats})
-        g.update_all(fn.u_mul_e('hv', 'dist', 'm_0'),
-                     fn.sum('m_0', 'hv_0'))
-        g.update_all(fn.copy_e('he', 'm_1'), fn.sum('m_1', 'hv_1'))
-        node_feats = g.ndata.pop('hv_0') + g.ndata.pop('hv_1')
+        g.ndata.update({"hv": node_feats})
+        g.edata.update({"dist": expanded_dists, "he": edge_feats})
+        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
+        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
+        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
 
         return node_feats, edge_feats
 
@@ -185,11 +184,10 @@ def __init__(self, feats, dist_feats):
         self.project_out_node_feats = nn.Sequential(
             nn.Linear(feats, feats),
             nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats)
+            nn.Linear(feats, feats),
         )
         self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats),
-            nn.Softplus(beta=0.5, threshold=14)
+            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
         )
 
     def reset_parameters(self):
@@ -224,7 +222,8 @@ def forward(self, g, node_feats, edge_feats, expanded_dists):
         """
         new_node_feats = self.project_in_node_feats(node_feats)
         new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists)
+            g, new_node_feats, edge_feats, expanded_dists
+        )
         new_node_feats = self.project_out_node_feats(new_node_feats)
         node_feats = node_feats + new_node_feats
 
@@ -257,8 +256,15 @@ class MGCNGNN(nn.Module):
         Difference between two adjacent centers in RBF expansion. Default to 0.1.
     """
 
-    def __init__(self, feats=128, n_layers=3, num_node_types=100,
-                 num_edge_types=3000, cutoff=30., gap=0.1):
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=30.0,
+        gap=0.1,
+    ):
         super(MGCNGNN, self).__init__()
 
         self.node_embed = nn.Embedding(num_node_types, feats)
@@ -269,8 +275,7 @@ def __init__(self, feats=128, n_layers=3, num_node_types=100,
 
         self.gnn_layers = nn.ModuleList()
         for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(
-                feats, len(self.rbf.centers)))
+            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
 
     def reset_parameters(self):
         """Reinitialize model parameters."""
@@ -305,7 +310,6 @@ def forward(self, g, node_types, edge_dists):
 
         all_layer_node_feats = [node_feats]
         for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(
-                g, node_feats, edge_feats, expanded_dists)
+            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
             all_layer_node_feats.append(node_feats)
         return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
index abaf7153..9f710fd3 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -40,26 +40,41 @@ class MGCNPredictor(nn.Module):
         Size for hidden representations in the output MLP predictor. Default to 64.
     """
 
-    def __init__(self, feats=128, n_layers=3, classifier_hidden_feats=64,
-                 n_tasks=1, num_node_types=100, num_edge_types=3000,
-                 cutoff=5.0, gap=1.0, predictor_hidden_feats=64):
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        classifier_hidden_feats=64,
+        n_tasks=1,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=5.0,
+        gap=1.0,
+        predictor_hidden_feats=64,
+    ):
         super(MGCNPredictor, self).__init__()
 
         if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print('classifier_hidden_feats is deprecated and will be removed in the future, '
-                  'use predictor_hidden_feats instead')
+            print(
+                "classifier_hidden_feats is deprecated and will be removed in the future, "
+                "use predictor_hidden_feats instead"
+            )
             predictor_hidden_feats = classifier_hidden_feats
 
-        self.gnn = MGCNGNN(feats=feats,
-                           n_layers=n_layers,
-                           num_node_types=num_node_types,
-                           num_edge_types=num_edge_types,
-                           cutoff=cutoff,
-                           gap=gap)
-        self.readout = MLPNodeReadout(node_feats=(n_layers + 1) * feats,
-                                      hidden_feats=predictor_hidden_feats,
-                                      graph_feats=n_tasks,
-                                      activation=nn.Softplus(beta=1, threshold=20))
+        self.gnn = MGCNGNN(
+            feats=feats,
+            n_layers=n_layers,
+            num_node_types=num_node_types,
+            num_edge_types=num_edge_types,
+            cutoff=cutoff,
+            gap=gap,
+        )
+        self.readout = MLPNodeReadout(
+            node_feats=(n_layers + 1) * feats,
+            hidden_feats=predictor_hidden_feats,
+            graph_feats=n_tasks,
+            activation=nn.Softplus(beta=1, threshold=20),
+        )
 
     def forward(self, g, node_types, edge_dists):
         """Graph-level regression/soft classification.
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index 6db28ce9..d2f69a2a 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,29 +1,34 @@
-
 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, mol,
-                 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:
@@ -43,7 +48,7 @@ def __init__(self, mol,
         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,35 +56,34 @@ def __init__(self, mol,
 
         self.requires_autograd = True
 
-        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))
+        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)
 
     def __repr__(self):
         """representation of the jastrow factor"""
         out = []
-        for k in ['ee', 'en', 'een']:
+        for k in ["ee", "en", "een"]:
             if self.jastrow_kernel_dict[k] is not None:
-                out.append(k + " -> " +
-                           self.jastrow_kernel_dict[k].__name__)
+                out.append(k + " -> " + self.jastrow_kernel_dict[k].__name__)
 
         return " + ".join(out)
 
@@ -105,69 +109,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:
@@ -177,15 +179,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:
@@ -196,25 +198,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..99929c5d 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -2,13 +2,16 @@
 from torch import nn
 
 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
 
 
 class AtomicOrbitals(nn.Module):
-
     def __init__(self, mol, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -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,94 @@ 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)
 
         self.cuda = cuda
-        self.device = torch.device('cpu')
+        self.device = torch.device("cpu")
         if self.cuda:
             self._to_device()
 
     def __repr__(self):
         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)
+        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):
         """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, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
+    ):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -161,10 +174,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 +187,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,7 +200,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, 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
@@ -258,9 +270,7 @@ 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])
 
@@ -296,10 +306,9 @@ 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)
 
@@ -320,12 +329,12 @@ 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
@@ -361,13 +370,11 @@ 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):
@@ -385,8 +392,7 @@ 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
@@ -405,13 +411,19 @@ 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)
 
@@ -432,13 +444,16 @@ 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
@@ -458,14 +473,16 @@ 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)
 
@@ -488,15 +505,25 @@ def _off_diag_hessian_kernel(self, R, dR, d2R, d2mR, Y, dY, d2Y, d2mY):
 
         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
@@ -522,19 +549,19 @@ def _compute_all_ao_values(self, 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):
         """Computes the positions/distance bewteen elec/orb
@@ -553,8 +580,10 @@ 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):
         """Computes the positions/distance bewteen elec/atoms
@@ -570,11 +599,10 @@ 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
 
@@ -589,9 +617,9 @@ 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
 
@@ -618,6 +646,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 d3a7dbd3..b1f124ad 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -3,7 +3,6 @@
 
 
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
-
     def __init__(self, mol, backflow, cuda=False):
         """Computes the value of atomic orbitals
 
@@ -16,7 +15,9 @@ def __init__(self, mol, backflow, cuda=False):
         dtype = torch.get_default_dtype()
         self.backflow_trans = backflow
 
-    def forward(self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False):
+    def forward(
+        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
+    ):
         """Computes the values of the atomic orbitals.
 
         .. math::
@@ -68,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
@@ -81,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)
@@ -96,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
@@ -179,7 +179,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:
@@ -194,8 +196,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)
@@ -221,14 +222,13 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
         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)
@@ -254,13 +254,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)
@@ -269,16 +275,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)
 
@@ -295,7 +300,6 @@ def _process_position(self, pos):
                                         (Nbatch, Nelec, Norb)
         """
         if self.backflow_trans.orbital_dependent:
-
             # get the elec-atom vectrors/distances
             xyz, r = self._elec_ao_dist(pos)
 
@@ -307,14 +311,15 @@ def _process_position(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))
+            return (
+                xyz.repeat_interleave(self.nshells, dim=2),
+                r.repeat_interleave(self.nshells, dim=2),
+            )
 
     def _elec_atom_dist(self, pos):
         """Computes the positions/distance bewteen elec/atoms
@@ -333,11 +338,10 @@ 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))
+        r = torch.sqrt((xyz * xyz).sum(3))
 
         return xyz, r
 
@@ -367,15 +371,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/atomic_orbitals_orbital_dependent_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
index 239bc732..50320839 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
 
@@ -16,12 +17,16 @@ 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):
+        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
@@ -177,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:
@@ -192,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)
@@ -219,14 +224,13 @@ def _compute_diag_hessian_backflow_ao_values(self, pos, hess_ao=None, mixed_ao=N
         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)
@@ -252,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)
@@ -267,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)
 
@@ -329,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/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 30d42d26..79ed8cee 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -6,8 +6,14 @@
 
 
 class BackFlowTransformation(nn.Module):
-
-    def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, orbital_dependent=False, cuda=False):
+    def __init__(
+        self,
+        mol,
+        backflow_kernel,
+        backflow_kernel_kwargs={},
+        orbital_dependent=False,
+        cuda=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
@@ -23,21 +29,19 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, orbital_depe
 
         if self.orbital_dependent:
             self.backflow_kernel = OrbitalDependentBackFlowKernel(
-                backflow_kernel, backflow_kernel_kwargs, mol, cuda)
+                backflow_kernel, backflow_kernel_kwargs, mol, cuda
+            )
         else:
-            self.backflow_kernel = backflow_kernel(mol,
-                                                   cuda,
-                                                   **backflow_kernel_kwargs)
+            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')
+            self.device = torch.device("cuda")
 
     def forward(self, pos, derivative=0):
-
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -49,7 +53,8 @@ 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 _get_backflow(self, pos):
         """Computes the backflow transformation
@@ -84,18 +89,18 @@ 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):
         """Computes the orbital dependent backflow transformation
@@ -115,20 +120,21 @@ def _backflow_od(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 _get_backflow_derivative(self, pos):
         r"""Computes the derivative of the backflow transformation
@@ -187,8 +193,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)
@@ -204,21 +211,18 @@ 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)
@@ -260,8 +264,11 @@ def _backflow_derivative_od(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)
@@ -278,26 +285,23 @@ def _backflow_derivative_od(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
@@ -365,8 +369,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
@@ -394,13 +399,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
@@ -408,8 +416,7 @@ 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)
@@ -452,8 +459,11 @@ def _backflow_second_derivative_od(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
@@ -482,13 +492,16 @@ def _backflow_second_derivative_od(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
@@ -496,12 +509,10 @@ def _backflow_second_derivative_od(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/backflow/kernels/backflow_kernel_autodiff_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
index f4479acb..1ffb230c 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,11 +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] = 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):
         """Computes the kernel via autodiff
@@ -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..a898b236 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelBase(nn.Module):
-
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,9 +14,9 @@ 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):
         """Computes the desired values of the kernel
@@ -39,8 +38,7 @@ 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):
         """Computes the kernel via autodiff
@@ -51,8 +49,7 @@ 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):
         """Computes the first derivative of the kernel via autodiff
@@ -84,7 +81,6 @@ 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)
 
@@ -113,10 +109,7 @@ def _hess(val, ree):
             pos ([type]): [description]
         """
 
-        gval = grad(val,
-                    ree,
-                    grad_outputs=torch.ones_like(val),
-                    create_graph=True)[0]
+        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]
 
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..196da707 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -5,7 +5,6 @@
 
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
-
     def __init__(self, mol, cuda):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -18,7 +17,7 @@ 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
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 18ce0a5a..1b562d13 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelInverse(BackFlowKernelBase):
-
     def __init__(self, mol, cuda=False):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -18,8 +17,7 @@ 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([1e-3]))  # .to(self.device)
 
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
@@ -36,7 +34,7 @@ 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):
         """Computes the derivative of the kernel function
@@ -52,8 +50,8 @@ 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):
         """Computes the derivative of the kernel function
@@ -69,5 +67,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..925dbd96 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -4,7 +4,6 @@
 
 
 class BackFlowKernelPowerSum(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, order=2):
         """Compute the back flow kernel, i.e. the function
         f(rij) where rij is the distance between electron i and j
@@ -15,8 +14,8 @@ 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):
         """Computes the kernel via autodiff
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
index f090a2bd..5cbe7f5a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -4,13 +4,13 @@
 
 
 class BackFlowKernelSquare(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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 84e28e02..92f9eef9 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -3,7 +3,6 @@
 
 
 class OrbitalDependentBackFlowKernel(nn.Module):
-
     def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
         """Compute orbital dependent back flow kernel, i.e. the functions
         f(rij) where rij is the distance between electron i and j
@@ -18,12 +17,16 @@ 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
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index 4fcec886..b216bc94 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -6,7 +6,6 @@
 
 
 class OrbitalDependentBackFlowTransformation(nn.Module):
-
     def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """Transform the electorn coordinates into backflow coordinates.
         see : Orbital-dependent backflow wave functions for real-space quantum Monte Carlo
@@ -21,16 +20,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')
+            self.device = torch.device("cuda")
 
     def forward(self, pos, derivative=0):
-
         if derivative == 0:
             return self._backflow(pos)
 
@@ -42,7 +41,8 @@ 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):
         """Computes the backflow transformation
@@ -62,20 +62,21 @@ 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):
         r"""Computes the derivative of the backflow transformation
@@ -108,8 +109,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,26 +130,23 @@ 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
@@ -183,8 +184,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 +217,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 +234,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/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 77ee6990..8b7d5546 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -17,34 +17,30 @@ 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, bas_exp):
@@ -60,9 +56,10 @@ def norm_slater_spherical(bas_n, bas_exp):
     Returns:
         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(
+        [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)
 
 
 def norm_gaussian_spherical(bas_n, bas_exp):
@@ -81,13 +78,14 @@ def norm_gaussian_spherical(bas_n, bas_exp):
     from scipy.special import factorial2 as f2
 
     bas_n = torch.tensor(bas_n)
-    bas_n = bas_n + 1.
-    exp1 = 0.25 * (2. * bas_n + 1.)
+    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)
-    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi **
-                        0.5).type(torch.get_default_dtype())
+    A = torch.tensor(bas_exp) ** exp1
+    B = 2 ** (2.0 * bas_n + 3.0 / 2)
+    C = torch.as_tensor(f2(2 * bas_n.int() - 1) * np.pi**0.5).type(
+        torch.get_default_dtype()
+    )
 
     return torch.sqrt(B / C) * A
 
@@ -108,23 +106,25 @@ def norm_slater_cartesian(a, b, c, n, exp):
     """
     from scipy.special import factorial2 as f2
 
-    lvals = a + b + c + n + 1.
+    lvals = a + b + c + n + 1.0
 
-    lfact = torch.as_tensor([np.math.factorial(int(2 * i))
-                             for i in lvals]).type(torch.get_default_dtype())
+    lfact = torch.as_tensor([np.math.factorial(int(2 * i)) for i in lvals]).type(
+        torch.get_default_dtype()
+    )
 
-    prefact = 4 * np.pi * lfact / ((2 * exp)**(2 * lvals + 1))
+    prefact = 4 * np.pi * lfact / ((2 * exp) ** (2 * lvals + 1))
 
-    num = torch.as_tensor(f2(2 * a.astype('int') - 1) *
-                          f2(2 * b.astype('int') - 1) *
-                          f2(2 * c.astype('int') - 1)
-                          ).type(torch.get_default_dtype())
+    num = torch.as_tensor(
+        f2(2 * a.astype("int") - 1)
+        * f2(2 * b.astype("int") - 1)
+        * f2(2 * c.astype("int") - 1)
+    ).type(torch.get_default_dtype())
 
-    denom = torch.as_tensor(
-        f2((2 * a + 2 * b + 2 * c + 1).astype('int')
-           )).type(torch.get_default_dtype())
+    denom = torch.as_tensor(f2((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):
@@ -143,14 +143,14 @@ def norm_gaussian_cartesian(a, b, c, exp):
 
     from scipy.special import factorial2 as f2
 
-    pref = torch.as_tensor((2 * exp / np.pi)**(0.75))
-    am1 = (2 * a - 1).astype('int')
-    x = (4 * exp)**(a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
+    pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
+    am1 = (2 * a - 1).astype("int")
+    x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
 
-    bm1 = (2 * b - 1).astype('int')
-    y = (4 * exp)**(b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
+    bm1 = (2 * b - 1).astype("int")
+    y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
 
-    cm1 = (2 * c - 1).astype('int')
-    z = (4 * exp)**(c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
+    cm1 = (2 * c - 1).astype("int")
+    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
 
     return (pref * x * y * z).type(torch.get_default_dtype())
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index e0070b9f..aa765cdd 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -2,8 +2,9 @@
 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, bas_n, bas_exp, xyz=None, derivative=0, sum_grad=True, sum_hess=True
+):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -48,48 +49,54 @@ def _first_derivative_kernel():
             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 """
+        """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():
         """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,21 +104,24 @@ 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)
+        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)
+    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):
+def radial_gaussian(
+    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
+):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -140,76 +150,83 @@ def _kernel():
         return rn * er
 
     def _first_derivative_kernel():
-
         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():
-
         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():
         """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
+    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)
+    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):
+def radial_gaussian_pure(
+    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
+):
     """Compute the radial part of GTOs (or its derivative).
 
     .. math:
@@ -247,12 +264,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,23 +283,26 @@ 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)
+    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):
+def radial_slater_pure(
+    R, bas_n, bas_exp, xyz=None, derivative=0, sum_grad=True, sum_hess=True
+):
     """Compute the radial part of STOs (or its derivative).
 
     .. math:
@@ -318,14 +339,14 @@ def _first_derivative_kernel():
             return nabla_er
 
     def _second_derivative_kernel():
-
         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():
@@ -334,8 +355,11 @@ def _mixed_second_derivative_kernel():
 
         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,19 +369,24 @@ 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,
+    _kernel,
+    _first_derivative_kernel,
+    _second_derivative_kernel,
+    _mixed_second_derivative_kernel,
+):
     """Returns the data contained in derivative
 
     Args:
@@ -372,10 +401,12 @@ def return_required_data(derivative, _kernel,
 
     # prepare the output/kernel
     output = []
-    fns = [_kernel,
-           _first_derivative_kernel,
-           _second_derivative_kernel,
-           _mixed_second_derivative_kernel]
+    fns = [
+        _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..01127598 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -3,7 +3,6 @@
 
 
 class Harmonics:
-
     def __init__(self, type, **kwargs):
         """Compute spherical or cartesian harmonics and their derivatives
 
@@ -29,35 +28,30 @@ 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
 
@@ -82,18 +76,27 @@ def __call__(self, xyz, derivative=[0], sum_grad=True, sum_hess=True):
             torch.tensor -- Values or gradient of the spherical 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')
+            raise ValueError("Harmonics type should be cart or sph")
 
 
-def CartesianHarmonics(xyz, k, mask0, mask2, derivative=[0],
-                       sum_grad=True, sum_hess=True):
+def CartesianHarmonics(
+    xyz, k, mask0, mask2, derivative=[0], sum_grad=True, sum_hess=True
+):
     r"""Computes Real Cartesian Harmonics
 
     .. math::
@@ -119,7 +122,7 @@ def _kernel():
         return xyz_k.prod(-1)
 
     def _first_derivative_kernel():
-        km1 = k-1
+        km1 = k - 1
         km1[km1 < 0] = 0
 
         xyz_km1 = fast_power(xyz, km1)
@@ -143,12 +146,9 @@ 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
@@ -156,30 +156,29 @@ def _second_derivative_kernel():
             return torch.stack((d2x, d2y, d2z), dim=-1)
 
     def _mixed_second_derivative_kernel():
-        km1 = k-1
+        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:
@@ -207,23 +206,22 @@ def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
     """
     if not sum_hess:
         raise NotImplementedError(
-            'SphericalHarmonics cannot return individual component of the laplacian')
+            "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)
 
 
@@ -248,42 +246,39 @@ 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
 
@@ -309,28 +304,27 @@ 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
 
 
@@ -374,6 +368,7 @@ def _lap_spherical_harmonics_l0(xyz):
     """
     return torch.zeros_like(xyz[..., 0])
 
+
 # =============== L1
 
 
@@ -407,7 +402,7 @@ 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):
@@ -427,22 +422,38 @@ 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))
+        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):
@@ -459,7 +470,8 @@ 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
 
@@ -481,16 +493,18 @@ 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):
@@ -513,17 +527,30 @@ 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):
@@ -550,39 +577,64 @@ 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))
+        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):
@@ -607,15 +659,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 c0d3aa9e..c89489b6 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -2,9 +2,7 @@
 
 
 class OrbitalConfigurations:
-
     def __init__(self, mol):
-
         self.nup = mol.nup
         self.ndown = mol.ndown
         self.nelec = self.nup + self.ndown
@@ -29,22 +27,22 @@ def get_configs(self, configs):
         if isinstance(configs, torch.Tensor):
             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)
@@ -52,10 +50,10 @@ 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)")
             raise ValueError("Config error")
 
     def sanity_check(self, nelec, norb):
@@ -68,12 +66,10 @@ def sanity_check(self, nelec, norb):
 
         """
         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
@@ -103,29 +99,21 @@ def _get_single_config(self, nocc, nvirt):
         _gs_down = list(range(self.ndown))
         cup, cdown = [_gs_up], [_gs_down]
 
-        for iocc in range(
-                self.nup - 1, self.nup - 1 - nocc[0], -1):
+        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)
+                _xt = self._create_excitation(_gs_up.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _xt, _gs_down)
+                cup, cdown = self._append_excitations(cup, cdown, _xt, _gs_down)
 
-        for iocc in range(
-                self.ndown - 1, self.ndown - 1 - nocc[1], -1):
+        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)
+                _xt = self._create_excitation(_gs_down.copy(), iocc, ivirt)
 
                 # append that excitation
-                cup, cdown = self._append_excitations(
-                    cup, cdown, _gs_up, _xt)
+                cup, cdown = self._append_excitations(cup, cdown, _gs_up, _xt)
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
@@ -143,48 +131,40 @@ 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[0], -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], -1))
-        idx_vrt_down = list(
-            range(self.ndown, self.ndown + nvirt[1], 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))
 
@@ -196,23 +176,22 @@ def _get_cas_config(self, nocc, nvirt, nelec):
             nvirt ([type]): number of virt orbitals in the CAS
         """
         from itertools import combinations, product
+
         if self.spin != 0:
             raise ValueError(
-                'CAS active space not possible with spin polarized calculation')
+                "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[0] - 1, self.nup + nvirt[0] - 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 = [], []
@@ -242,7 +221,7 @@ def _get_orb_number(self, nelec, norb):
             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])
+        nvirt = (norb - nocc[0], norb - nocc[1])
         return nocc, nvirt
 
     def _create_excitation(self, conf, iocc, ivirt):
@@ -316,7 +295,6 @@ def get_excitation(configs):
     """
     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()))
 
@@ -325,11 +303,19 @@ 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)
 
@@ -353,7 +339,6 @@ def get_unique_excitation(configs):
     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()))
 
@@ -361,11 +346,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)
@@ -374,7 +363,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)
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 5f1a3cae..a1c30ec1 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -2,7 +2,6 @@
 
 
 class OrbitalProjector:
-
     def __init__(self, configs, mol, cuda=False):
         """Project the MO matrix in Slater Matrices
 
@@ -17,9 +16,9 @@ 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')
+            self.device = torch.device("cuda")
 
     def get_projectors(self):
         """Get the projectors of the conf in the CI expansion
@@ -31,14 +30,12 @@ def get_projectors(self):
         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 ic, (cup, cdown) in enumerate(zip(self.configs[0], self.configs[1])):
             for _id, imo in enumerate(cup):
-                Pup[ic][imo, _id] = 1.
+                Pup[ic][imo, _id] = 1.0
 
             for _id, imo in enumerate(cdown):
-                Pdown[ic][imo, _id] = 1.
+                Pdown[ic][imo, _id] = 1.0
 
         return Pup.unsqueeze(1).to(self.device), Pdown.unsqueeze(1).to(self.device)
 
@@ -51,25 +48,23 @@ def split_orbitals(self, mat):
         Returns:
             torch.tensor: all slater matrices
         """
-        if not hasattr(self, 'Pup'):
+        if not hasattr(self, "Pup"):
             self.Pup, self.Pdown = self.get_projectors()
 
         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)
+            out_up = mat[..., : self.nup, :] @ self.Pup.unsqueeze(1)
+            out_down = mat[..., self.nup :, :] @ self.Pdown.unsqueeze(1)
 
         else:
             # case for single operator
-            out_up = mat[..., :self.nup, :] @ self.Pup
-            out_down = mat[..., self.nup:, :] @ self.Pdown
+            out_up = mat[..., : self.nup, :] @ self.Pup
+            out_down = mat[..., self.nup :, :] @ self.Pdown
 
         return out_up, out_down
 
 
 class ExcitationMask:
-
     def __init__(self, unique_excitations, mol, max_orb, cuda=False):
         """Select the occupied MOs of Slater determinant using masks
 
@@ -88,16 +83,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):
         """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 +100,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):
         """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 3091d04c..8ad51e01 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -32,7 +32,8 @@ 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
@@ -40,14 +41,16 @@ def __init__(self, config_method, configs, mol, cuda=False):
         self.nelec = self.nup + self.ndown
 
         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):
         """Computes the values of the determinats
@@ -58,7 +61,7 @@ def forward(self, input):
         Returns:
             torch.tensor: slater determinants
         """
-        if self.config_method.startswith('cas('):
+        if self.config_method.startswith("cas("):
             return self.det_explicit(input)
         else:
             return self.det_single_double(input)
@@ -99,12 +102,13 @@ def det_single_double(self, input):
         """
 
         # compute the determinant of the unique single excitation
-        det_unique_up, det_unique_down = self.det_unique_single_double(
-            input)
+        det_unique_up, det_unique_down = self.det_unique_single_double(input)
 
         # 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]])
+        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
@@ -113,8 +117,10 @@ def det_ground_state(self, input):
             input (torch.tensor): MO matrices nbatch x nelec x nmo
         """
 
-        return (torch.det(input[:, :self.nup, :self.nup]),
-                torch.det(input[:, self.nup:, :self.ndown]))
+        return (
+            torch.det(input[:, : self.nup, : self.nup]),
+            torch.det(input[:, self.nup :, : self.ndown]),
+        )
 
     def det_unique_single_double(self, input):
         """Computes the SD of single/double excitations
@@ -145,21 +151,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 +173,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,62 +181,57 @@ 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
 
@@ -248,18 +249,17 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
         """
 
         # 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'):
+        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("cas("):
             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:
@@ -280,18 +280,18 @@ def operator_ground_state(self, mo, bop, op_squared=False):
         """
 
         # occupied orbital matrix + det and inv on spin up
-        Aocc_up = mo[:, :self.nup, :self.nup]
+        Aocc_up = mo[:, : self.nup, : self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
+        Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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
@@ -328,7 +328,7 @@ def operator_explicit(self, mo, bkin, op_squared=False):
         Bup, Bdown = self.orb_proj.split_orbitals(bkin)
 
         # check ifwe have 1 or multiple ops
-        multiple_op = (Bup.ndim == 5)
+        multiple_op = Bup.ndim == 5
 
         # inverse of MO matrices
         iAup = torch.inverse(Aup)
@@ -373,11 +373,12 @@ def operator_single_double(self, mo, bop, op_squared=False):
             torch.tensor: kinetic energy values
         """
 
-        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)
 
-        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):
         """Compute the operator value of the unique single/double conformation
@@ -390,33 +391,33 @@ def operator_unique_single_double(self, mo, bop, op_squared):
 
         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]
+        Aocc_up = mo[:, : self.nup, : self.nup]
 
         # occupied orbital matrix + det and inv on spin down
-        Aocc_down = mo[:, self.nup:, :self.ndown]
+        Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
 
         # 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,73 +430,85 @@ 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_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_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:
-
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             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
         # typically trace(ABAB)
         else:
-
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -509,42 +522,56 @@ 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
 
@@ -566,7 +593,7 @@ def op_single(baseterm, mat_exc, M, index, nbatch):
         """
 
         # 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]
@@ -635,14 +662,14 @@ def op_squared_single(baseterm, mat_exc, M, Y, index, nbatch):
         """
 
         # 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
@@ -691,7 +718,7 @@ 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
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 358221f5..33fde499 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,5 +1,3 @@
-
-
 import torch
 from scipy.optimize import curve_fit
 from copy import deepcopy
@@ -19,14 +17,16 @@
 
 
 class SlaterJastrow(WaveFunction):
-
-    def __init__(self, mol,
-                 jastrow=None,
-                 backflow=None,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        jastrow=None,
+        backflow=None,
+        configs="ground_state",
+        kinetic="jacobi",
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
         .. math::
@@ -37,19 +37,19 @@ def __init__(self, mol,
         .. 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_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels        
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation    
+            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
             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
             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
@@ -61,16 +61,15 @@ def __init__(self, mol,
             >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
         """
 
-        super().__init__(mol.nelec, 3,  kinetic, cuda)
+        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')
+            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')
+        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
@@ -102,10 +101,7 @@ def __init__(self, mol,
         self.init_kinetic(kinetic, backflow)
 
         # register the callable for hdf5 dump
-        register_extra_attributes(self,
-                                  ['ao', 'mo_scf',
-                                   'mo', 'jastrow',
-                                   'pool', 'fc'])
+        register_extra_attributes(self, ["ao", "mo_scf", "mo", "jastrow", "pool", "fc"])
 
         self.log_data()
 
@@ -115,8 +111,7 @@ def init_atomic_orb(self, backflow):
         if self.backflow is None:
             self.ao = AtomicOrbitals(self.mol, self.cuda)
         else:
-            self.ao = AtomicOrbitalsBackFlow(
-                self.mol, self.backflow, self.cuda)
+            self.ao = AtomicOrbitalsBackFlow(self.mol, self.backflow, self.cuda)
 
         if self.cuda:
             self.ao = self.ao.to(self.device)
@@ -129,8 +124,7 @@ def init_molecular_orb(self, include_all_mo):
         self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
 
         # scf layer
-        self.mo_scf = nn.Linear(
-            self.mol.basis.nao, self.nmo_opt, bias=False)
+        self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
         self.mo_scf.weight = self.get_mo_coeffs()
         self.mo_scf.weight.requires_grad = False
 
@@ -145,8 +139,7 @@ def init_mo_mixer(self):
         self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
 
         # init the weight to idenity matrix
-        self.mo.weight = nn.Parameter(
-            torch.eye(self.nmo_opt, self.nmo_opt))
+        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
 
         # put on the card if needed
         if self.cuda:
@@ -160,15 +153,15 @@ def init_config(self, configs):
         self.configs_method = configs
         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
+        self.highest_occ_mo = max(self.configs[0].max(), self.configs[1].max()) + 1
 
     def init_slater_det_calculator(self):
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method,
-                                  self.configs, self.mol, self.cuda)
+        self.pool = SlaterPooling(
+            self.configs_method, self.configs, self.mol, self.cuda
+        )
 
     def init_fc_layer(self):
         """Init the fc layer"""
@@ -177,8 +170,8 @@ def init_fc_layer(self):
         self.fc = nn.Linear(self.nci, 1, bias=False)
 
         # set all weight to 0 except the groud state
-        self.fc.weight.data.fill_(0.)
-        self.fc.weight.data[0][0] = 1.
+        self.fc.weight.data.fill_(0.0)
+        self.fc.weight.data[0][0] = 1.0
 
         # port to card
         if self.cuda:
@@ -208,10 +201,10 @@ def set_combined_jastrow(self, jastrow):
         self.jastrow = CombineJastrow(jastrow)
 
     def init_kinetic(self, kinetic, backflow):
-        """"Init the calculator of the kinetic energies"""
+        """ "Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
-        if kinetic == 'jacobi':
+        if kinetic == "jacobi":
             if backflow is None:
                 self.kinetic_energy = self.kinetic_energy_jacobi
 
@@ -392,7 +385,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
@@ -405,11 +397,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
@@ -420,7 +411,7 @@ 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, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -434,10 +425,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
@@ -451,7 +439,7 @@ def get_kinetic_operator(self, x, ao, dao, d2ao,  mo):
 
         return -0.5 * bkin
 
-    def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
+    def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -485,8 +473,7 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -507,10 +494,12 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
         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 = (
+            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
 
@@ -518,9 +507,7 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -537,15 +524,13 @@ def kinetic_energy_jacobi_backflow(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -556,42 +541,37 @@ def gradients_jacobi_backflow(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
 
     def log_data(self):
         """Print information abut the wave function."""
-        log.info('')
-        log.info(' Wave Function')
-        log.info('  Jastrow factor      : {0}', self.use_jastrow)
+        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.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      : ')
+        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()])
+            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)
+        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))
+            log.info("  GPU                 : {0}", torch.cuda.get_device_name(0))
 
     def get_mo_coeffs(self):
         """Get the molecular orbital coefficients to init the mo layer."""
-        mo_coeff = torch.as_tensor(self.mol.basis.mos).type(
-            torch.get_default_dtype())
+        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]
+            mo_coeff = mo_coeff[:, : self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -610,20 +590,19 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-            xyz = self.ao.atom_coords[iat,
-                                      :].cpu().detach().numpy().tolist()
+            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
+        The SZ sto that have only one basis function per ao
         """
 
-        assert(self.ao.radial_type.startswith('gto'))
-        assert(self.ao.harmonics_type == 'cart')
+        assert self.ao.radial_type.startswith("gto")
+        assert self.ao.harmonics_type == "cart"
 
-        log.info('  Fit GTOs to STOs  : ')
+        log.info("  Fit GTOs to STOs  : ")
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -637,7 +616,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = 'sto_pure'
+        basis.radial_type = "sto_pure"
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -655,14 +634,12 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -673,16 +650,20 @@ def sto(x, norm, alpha):
             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()
+            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:
                 import matplotlib.pyplot as plt
+
                 plt.plot(xdata, ydata)
                 plt.plot(xdata, sto(xdata, *popt))
                 plt.show()
@@ -691,8 +672,12 @@ def sto(x, norm, alpha):
         new_mol.basis = basis
 
         # returns new orbital instance
-        return self.__class__(new_mol, self.jastrow, backflow=self.backflow,
-                              configs=self.configs_method,
-                              kinetic=self.kinetic_method,
-                              cuda=self.cuda,
-                              include_all_mo=self.include_all_mo)
+        return self.__class__(
+            new_mol,
+            self.jastrow,
+            backflow=self.backflow,
+            configs=self.configs_method,
+            kinetic=self.kinetic_method,
+            cuda=self.cuda,
+            include_all_mo=self.include_all_mo,
+        )
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 15cec289..e1b5e2d4 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -3,18 +3,22 @@
 
 from .slater_jastrow import SlaterJastrow
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        jastrow_kernel=PadeJastrowKernel,
+        jastrow_kernel_kwargs={},
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Slater Jastrow Wave function with an orbital dependent Electron-Electron Jastrow Factor
 
         .. math::
@@ -23,17 +27,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,7 +53,8 @@ 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, None, None, configs, kinetic, cuda, include_all_mo)
         self.use_jastrow = True
@@ -60,7 +65,8 @@ def __init__(self, mol,
             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)
@@ -176,21 +182,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])
 
@@ -200,10 +206,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)
@@ -212,7 +217,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, **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
         C. Filippi, Simple Formalism for Efficient Derivatives .
 
@@ -247,10 +252,12 @@ 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)
@@ -264,7 +271,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)
@@ -303,8 +311,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
@@ -334,12 +341,12 @@ 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):
         """Compute the gradient operator
@@ -370,7 +377,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/trash/slater_combined_jastrow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
index b308d190..b468f129 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
@@ -1,28 +1,31 @@
-
-
 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.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 .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):
+    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::
@@ -31,7 +34,7 @@ def __init__(self, mol, configs='ground_state',
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+            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
 
@@ -39,13 +42,13 @@ def __init__(self, mol, configs='ground_state',
             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 (dict, optional) : different Jastrow kernels for the different terms. 
+            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.
@@ -62,22 +65,23 @@ def __init__(self, mol, configs='ground_state',
 
         # process the Jastrow
         if jastrow_kernel is not None:
-
-            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():
                     jastrow_kernel_kwargs[k] = None
 
             self.use_jastrow = True
-            self.jastrow_type = 'JastrowFactorCombinedTerms'
+            self.jastrow_type = "JastrowFactorCombinedTerms"
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
+                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)
+                cuda=cuda,
+            )
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
diff --git a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
index 023ea286..e411e7c5 100644
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
@@ -1,38 +1,43 @@
-
-
 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.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 .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.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):
+    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::
@@ -41,7 +46,7 @@ def __init__(self, mol, configs='ground_state',
         with
 
         .. math::
-            J(r) = \\exp\\left( K_{ee}(r) + K_{en}(R_{at},r) + K_{een}(R_{at}, r) \\right)    
+            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
 
@@ -56,23 +61,23 @@ def __init__(self, mol, configs='ground_state',
             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 (dict, optional) : different Jastrow kernels for the different terms. 
+            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. 
+            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 
+            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
@@ -85,32 +90,35 @@ def __init__(self, mol, configs='ground_state',
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda
+            )
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                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']:
+            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_type = "JastrowFactorCombinedTerms"
 
             self.jastrow = JastrowFactorCombinedTerms(
-                self.mol.nup, self.mol.ndown,
+                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)
+                cuda=cuda,
+            )
 
             if self.cuda:
                 for term in self.jastrow.jastrow_terms:
@@ -183,7 +191,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    def kinetic_energy_jacobi(self, x, **kwargs):
         r"""Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -217,8 +225,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -239,10 +246,12 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         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 = (
+            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
 
@@ -250,9 +259,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -269,15 +276,13 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -288,4 +293,5 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
diff --git a/qmctorch/wavefunction/trash/slater_jastrow.py b/qmctorch/wavefunction/trash/slater_jastrow.py
index 81b84492..3cbae13c 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow.py
@@ -1,21 +1,24 @@
-
-
 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 .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 
 class SlaterJastrow(SlaterJastrowBase):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 jastrow_kernel=PadeJastrowKernel,
-                 jastrow_kernel_kwargs={},
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        jastrow_kernel=PadeJastrowKernel,
+        jastrow_kernel_kwargs={},
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Implementation of the QMC Network.
 
         Args:
@@ -36,12 +39,15 @@ def __init__(self, mol, configs='ground_state',
 
         # process the Jastrow
         if jastrow_kernel is not None:
-
             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)
+                self.mol.nup,
+                self.mol.ndown,
+                jastrow_kernel,
+                kernel_kwargs=jastrow_kernel_kwargs,
+                cuda=cuda,
+            )
 
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
@@ -213,7 +219,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
@@ -226,11 +231,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
@@ -241,7 +245,7 @@ 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, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -255,10 +259,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
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
index 38690d0a..da7b6cdb 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
@@ -1,5 +1,3 @@
-
-
 import torch
 
 from torch import nn
@@ -8,24 +6,31 @@
 from .. import log
 
 from .orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from .orbitals.atomic_orbitals_orbital_dependent_backflow import AtomicOrbitalsOrbitalDependentBackFlow
+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
+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):
+    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::
@@ -35,7 +40,7 @@ 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, and
 
         .. math::
@@ -49,22 +54,22 @@ def __init__(self, mol, configs='ground_state',
             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
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation. 
+            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation.
                 - By default an inverse kernel K(r_{ij}) = w/r_{ij} is used
             backflow_kernel_kwargs (dict, optional) : keyword arguments for the backflow kernel contructor
-            orbital_dependent_backflow (bool, optional) : every orbital has a different transformation if True. Default to False 
+            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
@@ -77,15 +82,21 @@ def __init__(self, mol, configs='ground_state',
         # process the backflow transformation
         if orbital_dependent_backflow:
             self.ao = AtomicOrbitalsOrbitalDependentBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                mol, backflow_kernel, backflow_kernel_kwargs, cuda
+            )
         else:
             self.ao = AtomicOrbitalsBackFlow(
-                mol, backflow_kernel, backflow_kernel_kwargs, cuda)
+                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)
+            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
@@ -162,7 +173,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    def kinetic_energy_jacobi(self, x, **kwargs):
         """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -196,8 +207,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         """
 
         # get ao values
-        ao, dao, d2ao = self.ao(
-            x, derivative=[0, 1, 2], sum_grad=False)
+        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
 
         # get the mo values
         mo = self.ao2mo(ao)
@@ -218,10 +228,12 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
         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 = (
+            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
 
@@ -229,9 +241,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             return -0.5 * hess
 
         # compute the Jastrow terms
-        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)
 
         # prepare the second derivative term d2Jast/Jast
         # Nbatch x Nelec
@@ -248,15 +258,13 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
 
         # prepare the grad of the dets
         # [Nelec*Ndim] x Nbatch x 1
-        grad_val = self.fc(operator.add(*grad) *
-                           slater_dets) / sum_slater_dets
+        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)
+        out = d2jast.sum(-1) + 2 * (grad_val * djast).sum(0) + hess.squeeze(-1)
 
         return -0.5 * out.unsqueeze(-1)
 
@@ -267,4 +275,5 @@ def gradients_jacobi(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            'Gradient through Jacobi formulat not implemented for backflow orbitals')
+            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+        )
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_base.py b/qmctorch/wavefunction/trash/slater_jastrow_base.py
index 3214b488..24a545eb 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_base.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_base.py
@@ -16,40 +16,40 @@
 
 
 class SlaterJastrowBase(WaveFunction):
-
-    def __init__(self, mol,
-                 configs='ground_state',
-                 kinetic='jacobi',
-                 cuda=False,
-                 include_all_mo=True):
+    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(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
             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)
+        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')
+            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')
+        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
@@ -61,7 +61,7 @@ def __init__(self, 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
+        self.highest_occ_mo = torch.stack(self.configs).max() + 1
 
         # define the atomic orbital layer
         self.ao = AtomicOrbitals(mol, cuda)
@@ -69,8 +69,7 @@ def __init__(self, mol,
         # 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 = 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:
@@ -79,8 +78,7 @@ def __init__(self, mol,
         # 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))
+        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
         if self.cuda:
             self.mo.to(self.device)
 
@@ -89,69 +87,59 @@ def __init__(self, mol,
         self.use_jastrow = False
 
         #  define the SD pooling layer
-        self.pool = SlaterPooling(self.configs_method,
-                                  self.configs, mol, cuda)
+        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.
+        self.fc.weight.data.fill_(0.0)
+        self.fc.weight.data[0][0] = 1.0
 
         if self.cuda:
             self.fc = self.fc.to(self.device)
 
         self.kinetic_method = kinetic
-        if kinetic == 'jacobi':
+        if kinetic == "jacobi":
             self.kinetic_energy = self.kinetic_energy_jacobi
 
-        gradients = 'auto'
+        gradients = "auto"
         self.gradients_method = gradients
-        if gradients == 'jacobi':
+        if gradients == "jacobi":
             self.gradients = self.gradients_jacobi
 
         if self.cuda:
-            self.device = torch.device('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'])
+        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)
+        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.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      : ')
+        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()])
+            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)
+        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))
+            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())
+        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]
+            mo_coeff = mo_coeff[:, : self.highest_occ_mo]
         return nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
     def update_mo_coeffs(self):
@@ -169,21 +157,19 @@ def geometry(self, pos):
         """
         d = []
         for iat in range(self.natom):
-
-            xyz = self.ao.atom_coords[iat,
-                                      :].cpu().detach().numpy().tolist()
+            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
+        The SZ sto that have only one basis function per ao
         """
 
-        assert(self.ao.radial_type.startswith('gto'))
-        assert(self.ao.harmonics_type == 'cart')
+        assert self.ao.radial_type.startswith("gto")
+        assert self.ao.harmonics_type == "cart"
 
-        log.info('  Fit GTOs to STOs  : ')
+        log.info("  Fit GTOs to STOs  : ")
 
         def sto(x, norm, alpha):
             """Fitting function."""
@@ -197,7 +183,7 @@ def sto(x, norm, alpha):
         basis = deepcopy(self.mol.basis)
 
         # change basis to sto
-        basis.radial_type = 'sto_pure'
+        basis.radial_type = "sto_pure"
         basis.nshells = self.ao.nao_per_atom.detach().cpu().numpy()
 
         # reset basis data
@@ -215,14 +201,12 @@ def sto(x, norm, alpha):
 
         # 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 = 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()
+        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]
@@ -233,12 +217,15 @@ def sto(x, norm, alpha):
             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()
+            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:
@@ -250,10 +237,13 @@ def sto(x, norm, alpha):
         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)
+        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
@@ -275,11 +265,11 @@ def forward(self, x, ao=None):
             >>> vals = wf(pos)
         """
 
-        raise NotImplementedError('Implement a forward method')
+        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')
+        raise NotImplementedError("Implement a ao2mo method")
 
     def pos2mo(self, x, derivative=0):
         """Get the values of MOs from the positions
@@ -293,9 +283,9 @@ def pos2mo(self, x, derivative=0):
         Returns:
             torch.tensor -- MO matrix [nbatch, nelec, nmo]
         """
-        raise NotImplementedError('Implement a get_mo_vals method')
+        raise NotImplementedError("Implement a get_mo_vals method")
 
-    def kinetic_energy_jacobi(self, x,  **kwargs):
+    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 .
 
@@ -309,8 +299,7 @@ def kinetic_energy_jacobi(self, x,  **kwargs):
             torch.tensor: values of the kinetic energy at each sampling points
         """
 
-        raise NotImplementedError(
-            'Implement a kinetic_energy_jacobi method')
+        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
@@ -327,8 +316,7 @@ def gradients_jacobi(self, x, pdf=False):
             torch.tensor: values of the gradients wrt the walker pos at each sampling points
         """
 
-        raise NotImplementedError(
-            'Implement a gradient_jacobi method')
+        raise NotImplementedError("Implement a gradient_jacobi method")
 
     def get_gradient_operator(self, x, ao, grad_ao, mo):
         """Compute the gradient operator
@@ -339,10 +327,9 @@ def get_gradient_operator(self, x, ao, grad_ao, mo):
             dao ([type]): [description]
         """
 
-        raise NotImplementedError(
-            'Implement a get_grad_operator method')
+        raise NotImplementedError("Implement a get_grad_operator method")
 
-    def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
+    def get_hessian_operator(self, x, ao, dao, d2ao, mo):
         """Compute the Bkin matrix
 
         Args:
@@ -353,5 +340,4 @@ def get_hessian_operator(self, x, ao, dao, d2ao,  mo):
             torch.tensor: matrix of the kinetic operator
         """
 
-        raise NotImplementedError(
-            'Implement a get_kinetic_operator method')
+        raise NotImplementedError("Implement a get_kinetic_operator method")
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_graph.py b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
index 2d5c7a19..727fce01 100644
--- a/qmctorch/wavefunction/trash/slater_jastrow_graph.py
+++ b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
@@ -1,27 +1,30 @@
-
-
 import numpy as np
 import torch
 from .slater_jastrow import SlaterJastrow
 
 from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from .jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 
 from .jastrows.graph.jastrow_graph import JastrowFactorGraph
 from .jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
 
 
 class SlaterJastrowGraph(SlaterJastrow):
-
-    def __init__(self, mol, configs='ground_state',
-                 kinetic='jacobi',
-                 ee_model=MGCNPredictor,
-                 ee_model_kwargs={},
-                 en_model=MGCNPredictor,
-                 en_model_kwargs={},
-                 atomic_features=["atomic_number"],
-                 cuda=False,
-                 include_all_mo=True):
+    def __init__(
+        self,
+        mol,
+        configs="ground_state",
+        kinetic="jacobi",
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+        include_all_mo=True,
+    ):
         """Implementation of a SlaterJastrow Network using Graph neural network to express the Jastrow.
 
         Args:
@@ -43,19 +46,23 @@ def __init__(self, mol, configs='ground_state',
 
         super().__init__(mol, configs, kinetic, None, None, cuda, include_all_mo)
 
-        self.jastrow_type = 'Graph(ee:%s, en:%s)' % (
-            ee_model.__name__, en_model.__name__)
+        self.jastrow_type = "Graph(ee:%s, en:%s)" % (
+            ee_model.__name__,
+            en_model.__name__,
+        )
         self.use_jastrow = True
-        self.jastrow = JastrowFactorGraph(mol.nup, mol.ndown,
-                                          torch.as_tensor(
-                                              mol.atom_coords),
-                                          mol.atoms,
-                                          ee_model=ee_model,
-                                          ee_model_kwargs=ee_model_kwargs,
-                                          en_model=en_model,
-                                          en_model_kwargs=en_model_kwargs,
-                                          atomic_features=atomic_features,
-                                          cuda=cuda)
+        self.jastrow = JastrowFactorGraph(
+            mol.nup,
+            mol.ndown,
+            torch.as_tensor(mol.atom_coords),
+            mol.atoms,
+            ee_model=ee_model,
+            ee_model_kwargs=ee_model_kwargs,
+            en_model=en_model,
+            en_model_kwargs=en_model_kwargs,
+            atomic_features=atomic_features,
+            cuda=cuda,
+        )
 
         if self.cuda:
             self.jastrow = self.jastrow.to(self.device)
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index 85fb5e55..e0067a71 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -4,9 +4,7 @@
 
 
 class WaveFunction(torch.nn.Module):
-
-    def __init__(self, nelec, ndim, kinetic='auto', cuda=False):
-
+    def __init__(self, nelec, ndim, kinetic="auto", cuda=False):
         super(WaveFunction, self).__init__()
 
         self.ndim = ndim
@@ -14,14 +12,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.
+        """Compute the value of the wave function.
         for a multiple conformation of the electrons
 
         Args:
@@ -29,7 +27,7 @@ def forward(self, x):
             pos: position of the electrons
 
         Returns: values of psi
-        '''
+        """
 
         raise NotImplementedError()
 
@@ -49,13 +47,11 @@ 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):
@@ -79,7 +75,7 @@ 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)
 
@@ -93,14 +89,14 @@ 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
 
@@ -118,13 +114,11 @@ 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
 
@@ -143,21 +137,16 @@ 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]
 
@@ -166,64 +155,66 @@ def kinetic_energy_autograd(self, pos):
     def local_energy(self, pos):
         """Computes the local energy
 
-         .. math::
-             E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
-
-         Args:
-             pos (torch.tensor): sampling points (Nbatch, 3*Nelec)
+        .. math::
+            E = K(R) + V_{ee}(R) + V_{en}(R) + V_{nn}
 
-         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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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.'''
+        """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):
         """Computes the total number of parameters."""
@@ -233,7 +224,7 @@ def get_number_parameters(self):
                 nparam += param.data.numel()
         return nparam
 
-    def load(self, filename, group='wf_opt', model='best'):
+    def load(self, filename, group="wf_opt", model="best"):
         """Load trained parameters
 
         Args:
@@ -242,8 +233,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)

From 7581cf4a24a2e1a94ee3f43dc039f9da6605ebce Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 14:36:21 +0100
Subject: [PATCH 097/286] removed trash wf

---
 .../trash/slater_combined_jastrow.py          |  90 -----
 .../trash/slater_combined_jastrow_backflow.py | 297 ---------------
 qmctorch/wavefunction/trash/slater_jastrow.py | 274 --------------
 .../trash/slater_jastrow_backflow.py          | 279 --------------
 .../wavefunction/trash/slater_jastrow_base.py | 343 ------------------
 .../trash/slater_jastrow_graph.py             |  70 ----
 6 files changed, 1353 deletions(-)
 delete mode 100644 qmctorch/wavefunction/trash/slater_combined_jastrow.py
 delete mode 100644 qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
 delete mode 100644 qmctorch/wavefunction/trash/slater_jastrow.py
 delete mode 100644 qmctorch/wavefunction/trash/slater_jastrow_backflow.py
 delete mode 100644 qmctorch/wavefunction/trash/slater_jastrow_base.py
 delete mode 100644 qmctorch/wavefunction/trash/slater_jastrow_graph.py

diff --git a/qmctorch/wavefunction/trash/slater_combined_jastrow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow.py
deleted file mode 100644
index b468f129..00000000
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow.py
+++ /dev/null
@@ -1,90 +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/trash/slater_combined_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
deleted file mode 100644
index e411e7c5..00000000
--- a/qmctorch/wavefunction/trash/slater_combined_jastrow_backflow.py
+++ /dev/null
@@ -1,297 +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/trash/slater_jastrow.py b/qmctorch/wavefunction/trash/slater_jastrow.py
deleted file mode 100644
index 3cbae13c..00000000
--- a/qmctorch/wavefunction/trash/slater_jastrow.py
+++ /dev/null
@@ -1,274 +0,0 @@
-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,
-)
-
-
-class SlaterJastrow(SlaterJastrowBase):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        jastrow_kernel=PadeJastrowKernel,
-        jastrow_kernel_kwargs={},
-        cuda=False,
-        include_all_mo=True,
-    ):
-        """Implementation of the QMC Network.
-
-        Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
-            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
-            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            jastrow_kernel_kwargs (dict, optional) : keyword arguments for the jastrow kernel contructor
-            cuda (bool, optional): turns GPU ON/OFF  Defaults to False.
-            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
-                                             popualted in the configs. Defaults to False
-        Examples::
-            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-        """
-
-        super().__init__(mol, configs, kinetic, cuda, include_all_mo)
-
-        # process the Jastrow
-        if jastrow_kernel is not None:
-            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,
-            )
-
-            if self.cuda:
-                self.jastrow = self.jastrow.to(self.device)
-
-        self.log_data()
-
-    def forward(self, x, ao=None):
-        """computes the value of the wave function for the sampling points
-
-        .. math::
-            \\Psi(R) =  \\sum_{n} c_n J(R) D^{u}_n(r^u) \\times D^{d}_n(r^d)
-
-        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)
-        """
-
-        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)
-
-        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))
-
-    def pos2mo(self, x, derivative=0):
-        """Get the values of MOs
-
-        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]
-        """
-        return self.mo(self.mo_scf(self.ao(x, derivative=derivative)))
-
-    def kinetic_energy_jacobi(self, x, **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
-        C. Filippi, Simple Formalism for Efficient Derivatives .
-
-        .. math::
-             \\frac{\Delta \\Psi(R)}{ \\Psi(R)} = \\Psi(R)^{-1} \\sum_n c_n (\\frac{\\Delta D_n^u}{D_n^u} + \\frac{\\Delta D_n^d}{D_n^d}) D_n^u D_n^d
-
-        We compute the laplacian of the determinants through the Jacobi formula
-
-        .. math::
-            \\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A)
-
-        Here A = J(R) phi and therefore :
-
-        .. math::
-            \\Delta A = (\\Delta J) D + 2 \\nabla J \\nabla D + (\\Delta D) J
-        Args:
-            x (torch.tensor): sampling points (Nbatch, 3*Nelec)
-
-        Returns:
-            torch.tensor: values of the kinetic energy at each sampling points
-        """
-
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2])
-        mo = self.ao2mo(ao)
-        bkin = self.get_kinetic_operator(x, ao, dao, d2ao, mo)
-
-        kin = self.pool.operator(mo, bkin)
-        psi = self.pool(mo)
-        out = self.fc(kin * psi) / self.fc(psi)
-        return out
-
-    def gradients_jacobi(self, x, sum_grad=False, 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})
-
-        The gradients of the wave function
-
-        .. math:
-            \\Psi(R) = J(R) \\sum_n c_n D^{u}_n D^{d}_n = J(R) \\Sigma
-
-        are computed following
-
-        .. math::
-            \\nabla \\Psi(R) = \\left( \\nabla J(R) \\right) \\Sigma + J(R) \\left(\\nabla \Sigma \\right)
-
-        with
-
-        .. math::
-
-            \\nabla \\Sigma =  \\sum_n c_n (\\frac{\\nabla D^u_n}{D^u_n} + \\frac{\\nabla D^d_n}{D^d_n}) D^u_n D^d_n
-
-        that we compute with the Jacobi formula as:
-
-        .. math::
-
-            \\nabla \\Sigma =  \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
-
-        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
-        """
-
-        # compute the mo values
-        mo = self.ao2mo(self.ao(x))
-
-        # compute the gradient operator matrix
-        grad_ao = self.ao(x, derivative=1, sum_grad=False)
-
-        # compute the derivatives of the MOs
-        dmo = self.ao2mo(grad_ao.transpose(2, 3)).transpose(2, 3)
-        dmo = dmo.permute(3, 0, 1, 2)
-
-        # stride the tensor
-        eye = torch.eye(self.nelec).to(self.device)
-        dmo = dmo.unsqueeze(2) * eye.unsqueeze(-1)
-
-        # reorder to have Nelec, Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.permute(2, 0, 1, 3, 4)
-
-        # flatten to have Nelec*Ndim, Nbatch, Nelec, Nmo
-        dmo = dmo.reshape(-1, *(dmo.shape[2:]))
-
-        # use the Jacobi formula to compute the value
-        # the grad of each determinants and sum up the terms :
-        # Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)
-        grad_dets = self.pool.operator(mo, dmo)
-
-        # compute the determinants
-        # D^u_n D^d_n
-        dets = self.pool(mo)
-
-        # assemble the final values of \nabla \Sigma
-        # \\sum_n c_n (Tr( (D^u_n)^-1 \\nabla D^u_n) + Tr( (D^d_n)^-1 \\nabla D^d_n)) D^u_n D^d_n
-        out = self.fc(grad_dets * dets)
-        out = out.transpose(0, 1).squeeze()
-
-        if self.use_jastrow:
-            nbatch = x.shape[0]
-
-            # nbatch x 1
-            jast = self.jastrow(x)
-
-            # nbatch x ndim x nelec
-            grad_jast = self.jastrow(x, derivative=1, sum_grad=False)
-
-            # reorder grad_jast to nbtach x Nelec x Ndim
-            grad_jast = grad_jast.permute(0, 2, 1)
-
-            # compute J(R) (\nabla\Sigma)
-            out = jast * out
-
-            # add the product (\nabla J(R)) \Sigma
-            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
-        if pdf:
-            out = 2 * out * self.fc(dets)
-            if self.use_jastrow:
-                out = out * jast
-
-        return out
-
-    def get_kinetic_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
-        """
-
-        bkin = self.ao2mo(d2ao)
-
-        if self.use_jastrow:
-            jast, djast, d2jast = self.jastrow(x, derivative=[0, 1, 2], sum_grad=False)
-
-            djast = djast.transpose(1, 2) / jast.unsqueeze(-1)
-            d2jast = d2jast / jast
-
-            dmo = self.ao2mo(dao.transpose(2, 3)).transpose(2, 3)
-
-            djast_dmo = (djast.unsqueeze(2) * dmo).sum(-1)
-            d2jast_mo = d2jast.unsqueeze(-1) * mo
-
-            bkin = bkin + 2 * djast_dmo + d2jast_mo
-
-        return -0.5 * bkin
diff --git a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py b/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
deleted file mode 100644
index da7b6cdb..00000000
--- a/qmctorch/wavefunction/trash/slater_jastrow_backflow.py
+++ /dev/null
@@ -1,279 +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/trash/slater_jastrow_base.py b/qmctorch/wavefunction/trash/slater_jastrow_base.py
deleted file mode 100644
index 24a545eb..00000000
--- a/qmctorch/wavefunction/trash/slater_jastrow_base.py
+++ /dev/null
@@ -1,343 +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.0)
-        self.fc.weight.data[0][0] = 1.0
-
-        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/trash/slater_jastrow_graph.py b/qmctorch/wavefunction/trash/slater_jastrow_graph.py
deleted file mode 100644
index 727fce01..00000000
--- a/qmctorch/wavefunction/trash/slater_jastrow_graph.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import numpy as np
-import torch
-from .slater_jastrow import SlaterJastrow
-
-from .jastrows.elec_elec.kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .jastrows.elec_elec.jastrow_factor_electron_electron import (
-    JastrowFactorElectronElectron,
-)
-
-from .jastrows.graph.jastrow_graph import JastrowFactorGraph
-from .jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
-
-
-class SlaterJastrowGraph(SlaterJastrow):
-    def __init__(
-        self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        ee_model=MGCNPredictor,
-        ee_model_kwargs={},
-        en_model=MGCNPredictor,
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-        include_all_mo=True,
-    ):
-        """Implementation of a SlaterJastrow Network using Graph neural network to express the Jastrow.
-
-        Args:
-            mol (qmc.wavefunction.Molecule): a molecule object
-            configs (str, optional): defines the CI configurations to be used. Defaults to 'ground_state'.
-            kinetic (str, optional): method to compute the kinetic energy. Defaults to 'jacobi'.
-            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): turns GPU ON/OFF  Defaults to False.
-            include_all_mo (bool, optional): include either all molecular orbitals or only the ones that are
-                                             popualted in the configs. Defaults to False
-        Examples::
-            >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp')
-            >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
-        """
-
-        super().__init__(mol, configs, kinetic, None, None, cuda, include_all_mo)
-
-        self.jastrow_type = "Graph(ee:%s, en:%s)" % (
-            ee_model.__name__,
-            en_model.__name__,
-        )
-        self.use_jastrow = True
-        self.jastrow = JastrowFactorGraph(
-            mol.nup,
-            mol.ndown,
-            torch.as_tensor(mol.atom_coords),
-            mol.atoms,
-            ee_model=ee_model,
-            ee_model_kwargs=ee_model_kwargs,
-            en_model=en_model,
-            en_model_kwargs=en_model_kwargs,
-            atomic_features=atomic_features,
-            cuda=cuda,
-        )
-
-        if self.cuda:
-            self.jastrow = self.jastrow.to(self.device)
-
-        self.log_data()

From d54d958023c1bd1c2de7ce254a852276b7785abd Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 14:45:12 +0100
Subject: [PATCH 098/286] removed unused import

---
 qmctorch/__init__.py                                       | 1 -
 qmctorch/sampler/pints_sampler.py                          | 2 --
 qmctorch/sampler/proposal_kernels.py                       | 6 ------
 qmctorch/sampler/state_dependent_normal_proposal.py        | 5 -----
 qmctorch/scf/molecule.py                                   | 1 -
 qmctorch/solver/solver_base.py                             | 2 --
 qmctorch/utils/__init__.py                                 | 6 ------
 qmctorch/wavefunction/jastrows/combine_jastrow.py          | 1 -
 qmctorch/wavefunction/jastrows/distance/__init__.py        | 2 --
 qmctorch/wavefunction/jastrows/elec_elec/__init__.py       | 6 ------
 .../wavefunction/jastrows/elec_elec/kernels/__init__.py    | 4 ----
 .../elec_elec/kernels/fully_connected_jastrow_kernel.py    | 1 -
 .../wavefunction/jastrows/elec_elec_nuclei/__init__.py     | 5 -----
 .../jastrows/elec_elec_nuclei/kernels/__init__.py          | 5 -----
 qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py     | 3 ---
 .../wavefunction/jastrows/elec_nuclei/kernels/__init__.py  | 3 ---
 qmctorch/wavefunction/jastrows/graph/__init__.py           | 2 --
 .../wavefunction/jastrows/jastrow_factor_combined_terms.py | 1 -
 qmctorch/wavefunction/orbitals/backflow/__init__.py        | 7 -------
 .../orbitals/backflow/backflow_transformation.py           | 1 -
 .../wavefunction/orbitals/backflow/kernels/__init__.py     | 6 ------
 .../orbitals/backflow/kernels/backflow_kernel_base.py      | 2 +-
 .../backflow/kernels/backflow_kernel_fully_connected.py    | 1 -
 .../orbitals/backflow/kernels/backflow_kernel_power_sum.py | 1 -
 .../backflow/orbital_dependent_backflow_transformation.py  | 1 -
 25 files changed, 1 insertion(+), 74 deletions(-)

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 9589dc8c..8ef2d99e 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
 
-from .__version__ import __version__
 
 __author__ = "Nicolas Renaud"
 __email__ = "n.renaud@esciencecenter.nl"
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index a81c03be..3920406c 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -1,9 +1,7 @@
-from tqdm import tqdm
 import torch
 import pints
 from typing import Callable, Union, Dict
 from .sampler_base import SamplerBase
-from .. import log
 
 
 class torch_model(pints.LogPDF):
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index eaa30c2e..7471056d 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -1,10 +1,4 @@
-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 DensityVarianceKernel(object):
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index b70a6a2b..1968e3fa 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -1,10 +1,5 @@
-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 StateDependentNormalProposal(object):
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index ba9a07d2..b3343dfa 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -1,5 +1,4 @@
 import os
-import math
 import numpy as np
 from mendeleev import element
 from types import SimpleNamespace
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index ce5c1f41..29a54092 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,9 +1,7 @@
-from threading import local
 from types import SimpleNamespace
 import os
 import numpy as np
 import torch
-from torch._C import Value
 from tqdm import tqdm
 
 from .. import log
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 10f8e555..e211db15 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -2,7 +2,6 @@
 
 from .algebra_utils import bdet2, bproj, btrace
 from .hdf5_utils import (
-    add_group_attr,
     dump_to_hdf5,
     load_from_hdf5,
     register_extra_attributes,
@@ -16,11 +15,6 @@
 #                         plot_integrated_autocorrelation_time,
 #                         plot_walkers_traj)
 
-from .stat_utils import (
-    blocking,
-    correlation_coefficient,
-    integrated_autocorrelation_time,
-)
 from .torch_utils import (
     DataSet,
     DataLoader,
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 70fd8ee3..972266be 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/jastrows/distance/__init__.py b/qmctorch/wavefunction/jastrows/distance/__init__.py
index a34c958e..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/distance/__init__.py
+++ b/qmctorch/wavefunction/jastrows/distance/__init__.py
@@ -1,2 +0,0 @@
-from .electron_electron_distance import ElectronElectronDistance
-from .electron_nuclei_distance import ElectronNucleiDistance
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index 98540879..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -1,6 +0,0 @@
-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
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
index f9413743..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
@@ -1,4 +0,0 @@
-from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
-from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
-from .pade_jastrow_kernel import PadeJastrowKernel
-from .pade_jastrow_polynomial_kernel import 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 b9407339..9b24d53b 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,6 +1,5 @@
 import torch
 from torch import nn
-import numpy as np
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index 8c4b6053..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -1,5 +0,0 @@
-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
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
index 7810c835..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -1,5 +0,0 @@
-from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
-from .jastrow_kernel_electron_electron_nuclei_base import (
-    JastrowKernelElectronElectronNucleiBase,
-)
-from .boys_handy_jastrow_kernel import BoysHandyJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index 226011ff..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -1,3 +0,0 @@
-from .jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei as JastrowFactor
-from .kernels.pade_jastrow_kernel import PadeJastrowKernel
-from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
index 177e5efb..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
@@ -1,3 +0,0 @@
-from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
-from .jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
-from .pade_jastrow_kernel import PadeJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index 600125c6..e69de29b 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,2 +0,0 @@
-from .jastrow_graph import JastrowFactorGraph as JastrowFactor
-from .mgcn.mgcn_predictor import MGCNPredictor
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index d2f69a2a..a6b8329c 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index 7fecfefd..e69de29b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -1,7 +0,0 @@
-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
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 79ed8cee..0bc8f650 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,4 +1,3 @@
-import numpy
 import torch
 from torch import nn
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index 4b96dfc2..e69de29b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -1,6 +0,0 @@
-from .backflow_kernel_base import BackFlowKernelBase
-from .backflow_kernel_autodiff_inverse import BackFlowKernelAutoInverse
-from .backflow_kernel_fully_connected import BackFlowKernelFullyConnected
-from .backflow_kernel_inverse import BackFlowKernelInverse
-from .backflow_kernel_power_sum import BackFlowKernelPowerSum
-from .backflow_kernel_square import BackFlowKernelSquare
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index a898b236..4a838bc3 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
+from torch.autograd import grad
 
 
 class BackFlowKernelBase(nn.Module):
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 196da707..9292493f 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -1,6 +1,5 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
 from .backflow_kernel_base import BackFlowKernelBase
 
 
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 925dbd96..053f8eee 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index b216bc94..18f8f587 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -1,4 +1,3 @@
-import numpy
 import torch
 from torch import nn
 from ...jastrows.distance.electron_electron_distance import ElectronElectronDistance

From 0fe3590f3fedee018a6ef56ed4f5936cc35c354d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 15:13:36 +0100
Subject: [PATCH 099/286] critical error

---
 qmctorch/scf/calculator/adf.py          | 2 +-
 qmctorch/wavefunction/slater_jastrow.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index a63d7f72..5755132a 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -258,7 +258,7 @@ def read_array(kf, section, name):
 class CalculatorADF2019(CalculatorADF):
     def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, savefile
+            self, atoms, atom_coords, basis, scf, units, molname, 'adf', savefile
         )
 
         self.adf_version = "adf2019"
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 33fde499..37a94032 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -206,6 +206,7 @@ def init_kinetic(self, kinetic, backflow):
         self.kinetic_method = kinetic
         if kinetic == "jacobi":
             if backflow is None:
+                self.gradients_jacobi = self.gradients_jacobi_no_backflow
                 self.kinetic_energy = self.kinetic_energy_jacobi
 
             else:
@@ -313,7 +314,7 @@ 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_no_backflow(self, x, sum_grad=False, pdf=False):
         """Compute the gradients of the wave function (or density) using the Jacobi Formula
         C. Filippi, Simple Formalism for Efficient Derivatives.
 

From 9784ea16035941d873e041879f199026a9ae1b2d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 15:14:20 +0100
Subject: [PATCH 100/286] unused import in test

---
 tests/solver/test_base_solver.py                              | 3 ---
 tests/solver/test_h2_adf_jacobi.py                            | 1 -
 tests/solver/test_h2_pyscf_geo_opt.py                         | 4 ----
 tests/solver/test_h2_pyscf_metropolis.py                      | 1 -
 tests/solver/test_lih_pyscf_backflow.py                       | 1 -
 tests/solver/test_lih_pyscf_compare_backflow.py               | 1 -
 tests/solver/test_lih_pyscf_generic_backflow.py               | 1 -
 tests/solver/test_lih_pyscf_orbital_dependent_backflow.py     | 1 -
 tests/wavefunction/base_test_cases.py                         | 1 -
 .../wavefunction/jastrows/distance/test_elec_elec_distance.py | 2 +-
 .../jastrows/elec_elec/base_elec_elec_jastrow_test.py         | 1 -
 tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py        | 1 -
 .../elec_elec_nuc/test_three_body_jastrow_boys_handy.py       | 2 +-
 .../elec_elec_nuc/test_three_body_jastrow_fully_connected.py  | 2 +-
 tests/wavefunction/jastrows/test_combined_terms.py            | 2 +-
 .../orbitals/backflow/test_backflow_kernel_generic_pyscf.py   | 1 -
 .../orbitals/backflow/test_backflow_kernel_inverse_pyscf.py   | 3 +--
 .../orbitals/backflow/test_backflow_transformation_pyscf.py   | 3 +--
 .../test_orbital_dependent_backflow_transformation_pyscf.py   | 1 -
 tests/wavefunction/orbitals/test_ao_derivatives_adf.py        | 1 -
 .../orbitals/test_backflow_ao_derivatives_pyscf.py            | 4 +---
 tests/wavefunction/orbitals/test_cartesian_harmonics.py       | 1 -
 .../test_orbital_dependent_backflow_ao_derivatives_pyscf.py   | 4 +---
 tests/wavefunction/orbitals/test_radial_gto.py                | 1 -
 tests/wavefunction/orbitals/test_radial_sto.py                | 1 -
 tests/wavefunction/orbitals/test_spherical_harmonics.py       | 1 -
 tests/wavefunction/test_slaterjastrow_ee_cusp.py              | 2 +-
 27 files changed, 9 insertions(+), 38 deletions(-)

diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 594eb2f6..54d16c6e 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,8 +1,5 @@
 import unittest
 
-import numpy as np
-import torch
-import torch.optim as optim
 
 
 class BaseTestSolvers:
diff --git a/tests/solver/test_h2_adf_jacobi.py b/tests/solver/test_h2_adf_jacobi.py
index 950a7686..e2118c3f 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -1,6 +1,5 @@
 import unittest
 
-import numpy as np
 import torch
 import torch.optim as optim
 
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index ff62759e..31466dd0 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -6,10 +6,6 @@
 
 
 from qmctorch.sampler import Metropolis
-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.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 15bc1f28..ea407fb9 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -1,4 +1,3 @@
-from qmctorch.wavefunction import jastrows
 import unittest
 
 import numpy as np
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 1d6cc922..0d6f13ff 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
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index dec3033a..0f97b992 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
diff --git a/tests/solver/test_lih_pyscf_generic_backflow.py b/tests/solver/test_lih_pyscf_generic_backflow.py
index d8486308..c7fdffad 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
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index 118d994d..b1ad4faf 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
diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index bfa699bb..5f7d39b3 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -1,7 +1,6 @@
 import unittest
 from torch.autograd import grad, gradcheck, Variable
 
-import numpy as np
 import torch
 
 
diff --git a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
index f0560f72..6024fb77 100644
--- a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
+++ b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
@@ -1,5 +1,5 @@
 import torch
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 from qmctorch.wavefunction.jastrows.distance import ElectronElectronDistance
 import unittest
 
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
index 745bb179..9d96445f 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -1,7 +1,6 @@
 import unittest
 from torch.autograd import grad, gradcheck, Variable
 
-import numpy as np
 import torch
 
 
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 5d116766..76e07580 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
 
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 d7c3f2c1..5e903dab 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
@@ -2,7 +2,7 @@
 from types import SimpleNamespace
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 
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 1227ba48..91e7accc 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
@@ -2,7 +2,7 @@
 from types import SimpleNamespace
 import numpy as np
 import torch
-from torch.autograd import Variable, grad, gradcheck
+from torch.autograd import Variable, grad
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index e53b5216..3283bd9c 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -7,7 +7,7 @@
 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.elec_elec_nuclei.kernels import BoysHandyJastrowKernel
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
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 4be0c43f..19d444a4 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
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 0001d1cd..4f6980ed 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -1,8 +1,7 @@
 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
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index 4334c918..a649f03f 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -1,8 +1,7 @@
 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
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 eb5d1d03..d7ac6573 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,7 +1,6 @@
 import unittest
 
 import torch
-from pyscf import gto
 from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
index 6038d514..f3322694 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -1,6 +1,5 @@
 from ...path_utils import PATH_TEST
 import unittest
-import numpy as np
 import torch
 
 from .base_test_ao import BaseTestAO
diff --git a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
index c4a19bc5..0bffd269 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -1,11 +1,9 @@
 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.backflow.backflow_transformation import BackFlowTransformation
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics.py b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
index ccc1c754..7614c1c1 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
 
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 d2351fd3..fd2245d0 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,11 +1,9 @@
 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.backflow.backflow_transformation import BackFlowTransformation
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
diff --git a/tests/wavefunction/orbitals/test_radial_gto.py b/tests/wavefunction/orbitals/test_radial_gto.py
index b7e90ebe..19aef652 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -4,7 +4,6 @@
 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
 
diff --git a/tests/wavefunction/orbitals/test_radial_sto.py b/tests/wavefunction/orbitals/test_radial_sto.py
index 9883c120..91f74f58 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -8,7 +8,6 @@
 from ...path_utils import PATH_TEST
 from .second_derivative import second_derivative
 
-import matplotlib.pyplot as plt
 
 
 class TestRadialSlater(unittest.TestCase):
diff --git a/tests/wavefunction/orbitals/test_spherical_harmonics.py b/tests/wavefunction/orbitals/test_spherical_harmonics.py
index 4d6b3d4c..0300faf3 100644
--- a/tests/wavefunction/orbitals/test_spherical_harmonics.py
+++ b/tests/wavefunction/orbitals/test_spherical_harmonics.py
@@ -1,6 +1,5 @@
 import unittest
 
-import numpy as np
 import torch
 
 from qmctorch.wavefunction.orbitals.spherical_harmonics import Harmonics
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index 4dc1ffbc..8f0ca6b7 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -9,7 +9,7 @@
 from qmctorch.utils import set_torch_double_precision
 
 from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel, PadeJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)

From 9ab7ae8f072354b8bb7520b3a498e08b4ecbcf2b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 15:28:12 +0100
Subject: [PATCH 101/286] gradient no backflow

---
 tests/wavefunction/base_test_cases.py                      | 7 ++++++-
 .../jastrows/elec_elec/base_elec_elec_jastrow_test.py      | 7 ++++++-
 tests/wavefunction/orbitals/base_test_ao.py                | 6 +++++-
 tests/wavefunction/test_slater_mgcn_graph_jastrow.py       | 4 ++--
 4 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index 5f7d39b3..3a62bc19 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -34,8 +34,13 @@ class WaveFunctionBaseTest(unittest.TestCase):
 
         def setUp(self):
             """Init the base test"""
+
+            def wf_placeholder(pos):
+                """Callable for wf"""
+                return None
+            
             self.pos = None
-            self.wf = None
+            self.wf = wf_placeholder
             self.nbatch = None
 
         def test_forward(self):
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
index 9d96445f..58709350 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -34,7 +34,12 @@ class ElecElecJastrowBaseTest(unittest.TestCase):
 
         def setUp(self) -> None:
             """Init the test case"""
-            self.jastrow = None
+
+            def jastrow_callable(pos):
+                """Empty callable for jastrow"""
+                return None 
+            
+            self.jastrow = jastrow_callable
             self.nbatch = None
             self.pos = None
 
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index dd06a9fc..fa1c9f8f 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -72,7 +72,11 @@ class BaseTestAO:
     class BaseTestAOderivatives(unittest.TestCase):
 
         def setUp(self):
-            self.ao = None
+
+            def ao_callable(pos):
+                """Callable for the AO"""
+                return None
+            self.ao = ao_callable
             self.pos = None
 
         def test_ao_deriv(self):
diff --git a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
index 6f899ae4..2b29baa8 100644
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -169,7 +169,7 @@ def test_kinetic_energy(self):
 
     def test_gradients_wf(self):
 
-        grads = self.wf.gradients_jacobi(
+        grads = self.wf.gradients_jacobi_no_backflow(
             self.pos, sum_grad=False).squeeze()
         grad_auto = self.wf.gradients_autograd(self.pos)
 
@@ -181,7 +181,7 @@ def test_gradients_wf(self):
 
     def test_gradients_pdf(self):
 
-        grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
+        grads_pdf = self.wf.gradients_jacobi_no_backflow(self.pos, pdf=True)
         grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
 
         assert torch.allclose(grads_pdf.sum(), grads_auto.sum())

From 218424f74796db548fd41789ed25b7dbf300e997 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Nov 2023 16:55:18 +0100
Subject: [PATCH 102/286] Revert "removed unused import"

This reverts commit d54d958023c1bd1c2de7ce254a852276b7785abd.
---
 qmctorch/__init__.py                                       | 1 +
 qmctorch/sampler/pints_sampler.py                          | 2 ++
 qmctorch/sampler/proposal_kernels.py                       | 6 ++++++
 qmctorch/sampler/state_dependent_normal_proposal.py        | 5 +++++
 qmctorch/scf/molecule.py                                   | 1 +
 qmctorch/solver/solver_base.py                             | 2 ++
 qmctorch/utils/__init__.py                                 | 6 ++++++
 qmctorch/wavefunction/jastrows/combine_jastrow.py          | 1 +
 qmctorch/wavefunction/jastrows/distance/__init__.py        | 2 ++
 qmctorch/wavefunction/jastrows/elec_elec/__init__.py       | 6 ++++++
 .../wavefunction/jastrows/elec_elec/kernels/__init__.py    | 4 ++++
 .../elec_elec/kernels/fully_connected_jastrow_kernel.py    | 1 +
 .../wavefunction/jastrows/elec_elec_nuclei/__init__.py     | 5 +++++
 .../jastrows/elec_elec_nuclei/kernels/__init__.py          | 5 +++++
 qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py     | 3 +++
 .../wavefunction/jastrows/elec_nuclei/kernels/__init__.py  | 3 +++
 qmctorch/wavefunction/jastrows/graph/__init__.py           | 2 ++
 .../wavefunction/jastrows/jastrow_factor_combined_terms.py | 1 +
 qmctorch/wavefunction/orbitals/backflow/__init__.py        | 7 +++++++
 .../orbitals/backflow/backflow_transformation.py           | 1 +
 .../wavefunction/orbitals/backflow/kernels/__init__.py     | 6 ++++++
 .../orbitals/backflow/kernels/backflow_kernel_base.py      | 2 +-
 .../backflow/kernels/backflow_kernel_fully_connected.py    | 1 +
 .../orbitals/backflow/kernels/backflow_kernel_power_sum.py | 1 +
 .../backflow/orbital_dependent_backflow_transformation.py  | 1 +
 25 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 8ef2d99e..9589dc8c 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
 
+from .__version__ import __version__
 
 __author__ = "Nicolas Renaud"
 __email__ = "n.renaud@esciencecenter.nl"
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index 3920406c..a81c03be 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -1,7 +1,9 @@
+from tqdm import tqdm
 import torch
 import pints
 from typing import Callable, Union, Dict
 from .sampler_base import SamplerBase
+from .. import log
 
 
 class torch_model(pints.LogPDF):
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index 7471056d..eaa30c2e 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -1,4 +1,10 @@
+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 DensityVarianceKernel(object):
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index 1968e3fa..b70a6a2b 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -1,5 +1,10 @@
+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 StateDependentNormalProposal(object):
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index b3343dfa..ba9a07d2 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -1,4 +1,5 @@
 import os
+import math
 import numpy as np
 from mendeleev import element
 from types import SimpleNamespace
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 29a54092..ce5c1f41 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,7 +1,9 @@
+from threading import local
 from types import SimpleNamespace
 import os
 import numpy as np
 import torch
+from torch._C import Value
 from tqdm import tqdm
 
 from .. import log
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index e211db15..10f8e555 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -2,6 +2,7 @@
 
 from .algebra_utils import bdet2, bproj, btrace
 from .hdf5_utils import (
+    add_group_attr,
     dump_to_hdf5,
     load_from_hdf5,
     register_extra_attributes,
@@ -15,6 +16,11 @@
 #                         plot_integrated_autocorrelation_time,
 #                         plot_walkers_traj)
 
+from .stat_utils import (
+    blocking,
+    correlation_coefficient,
+    integrated_autocorrelation_time,
+)
 from .torch_utils import (
     DataSet,
     DataLoader,
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 972266be..70fd8ee3 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,3 +1,4 @@
+import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/jastrows/distance/__init__.py b/qmctorch/wavefunction/jastrows/distance/__init__.py
index e69de29b..a34c958e 100644
--- a/qmctorch/wavefunction/jastrows/distance/__init__.py
+++ b/qmctorch/wavefunction/jastrows/distance/__init__.py
@@ -0,0 +1,2 @@
+from .electron_electron_distance import ElectronElectronDistance
+from .electron_nuclei_distance import ElectronNucleiDistance
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index e69de29b..98540879 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -0,0 +1,6 @@
+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
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
index e69de29b..f9413743 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
@@ -0,0 +1,4 @@
+from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
+from .pade_jastrow_kernel import PadeJastrowKernel
+from .pade_jastrow_polynomial_kernel import 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 9b24d53b..b9407339 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,5 +1,6 @@
 import torch
 from torch import nn
+import numpy as np
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index e69de29b..8c4b6053 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -0,0 +1,5 @@
+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
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
index e69de29b..7810c835 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -0,0 +1,5 @@
+from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from .jastrow_kernel_electron_electron_nuclei_base import (
+    JastrowKernelElectronElectronNucleiBase,
+)
+from .boys_handy_jastrow_kernel import BoysHandyJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index e69de29b..226011ff 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -0,0 +1,3 @@
+from .jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei as JastrowFactor
+from .kernels.pade_jastrow_kernel import PadeJastrowKernel
+from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
index e69de29b..177e5efb 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
@@ -0,0 +1,3 @@
+from .fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from .jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
+from .pade_jastrow_kernel import PadeJastrowKernel
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index e69de29b..600125c6 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -0,0 +1,2 @@
+from .jastrow_graph import JastrowFactorGraph as JastrowFactor
+from .mgcn.mgcn_predictor import MGCNPredictor
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index a6b8329c..d2f69a2a 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,3 +1,4 @@
+import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index e69de29b..7fecfefd 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -0,0 +1,7 @@
+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
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 0bc8f650..79ed8cee 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,3 +1,4 @@
+import numpy
 import torch
 from torch import nn
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index e69de29b..4b96dfc2 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -0,0 +1,6 @@
+from .backflow_kernel_base import BackFlowKernelBase
+from .backflow_kernel_autodiff_inverse import BackFlowKernelAutoInverse
+from .backflow_kernel_fully_connected import BackFlowKernelFullyConnected
+from .backflow_kernel_inverse import BackFlowKernelInverse
+from .backflow_kernel_power_sum import BackFlowKernelPowerSum
+from .backflow_kernel_square import BackFlowKernelSquare
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 4a838bc3..a898b236 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from torch.autograd import grad
+from torch.autograd import grad, Variable
 
 
 class BackFlowKernelBase(nn.Module):
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 9292493f..196da707 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -1,5 +1,6 @@
 import torch
 from torch import nn
+from torch.autograd import grad, Variable
 from .backflow_kernel_base import BackFlowKernelBase
 
 
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 053f8eee..925dbd96 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -1,3 +1,4 @@
+import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index 18f8f587..b216bc94 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -1,3 +1,4 @@
+import numpy
 import torch
 from torch import nn
 from ...jastrows.distance.electron_electron_distance import ElectronElectronDistance

From 87ca4607ca8c0eafea622d2dcc2e132beb921e7a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 09:52:39 +0100
Subject: [PATCH 103/286] add charge and spin to adf

---
 qmctorch/scf/calculator/adf.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 5755132a..fe5e02f0 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -256,9 +256,9 @@ def read_array(kf, section, name):
 
 
 class CalculatorADF2019(CalculatorADF):
-    def __init__(self, atoms, atom_coords, basis, scf, units, molname, savefile):
+    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
         CalculatorADF.__init__(
-            self, atoms, atom_coords, basis, scf, units, molname, 'adf', savefile
+            self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
         )
 
         self.adf_version = "adf2019"
@@ -297,4 +297,7 @@ def get_plams_settings(self):
         # total energy
         sett.input.totalenergy = True
 
+        # charge info
+        sett.input.charge = "%d %d" % (self.charge, self.spin)
+
         return sett

From 2a0af70a23620898f24fe52ae7f1babb5f6bfe2a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 09:52:52 +0100
Subject: [PATCH 104/286] fix test gradients no backflow

---
 tests/wavefunction/base_test_cases.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index 3a62bc19..16226c6f 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -135,7 +135,7 @@ def test_kinetic_energy(self):
 
         def test_gradients_wf(self):
 
-            grads = self.wf.gradients_jacobi(
+            grads = self.wf.gradients_jacobi_no_backflow(
                 self.pos, sum_grad=False).squeeze()
             grad_auto = self.wf.gradients_autograd(self.pos)
 
@@ -148,7 +148,7 @@ def test_gradients_wf(self):
 
         def test_gradients_pdf(self):
 
-            grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
+            grads_pdf = self.wf.gradients_jacobi_no_backflow(self.pos, pdf=True)
             grads_auto = self.wf.gradients_autograd(
                 self.pos, pdf=True)
 

From eca0db0d9cc429cdc5ace5dde845f7f57e94da8f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 10:03:41 +0100
Subject: [PATCH 105/286] fix callable jastrow args

---
 tests/wavefunction/base_test_cases.py                           | 2 +-
 .../jastrows/elec_elec/base_elec_elec_jastrow_test.py           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index 16226c6f..361fad03 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -35,7 +35,7 @@ class WaveFunctionBaseTest(unittest.TestCase):
         def setUp(self):
             """Init the base test"""
 
-            def wf_placeholder(pos):
+            def wf_placeholder(pos, **kwargs):
                 """Callable for wf"""
                 return None
             
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
index 58709350..59703ffd 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -35,7 +35,7 @@ class ElecElecJastrowBaseTest(unittest.TestCase):
         def setUp(self) -> None:
             """Init the test case"""
 
-            def jastrow_callable(pos):
+            def jastrow_callable(pos, derivative=0, sum_grad=False):
                 """Empty callable for jastrow"""
                 return None 
             

From 95fd44e90a0b16d924ed57e4743d4f89945848db Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 10:22:09 +0100
Subject: [PATCH 106/286] reverted gradient no backflow

---
 qmctorch/wavefunction/slater_jastrow.py | 5 ++---
 tests/wavefunction/base_test_cases.py   | 4 ++--
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 37a94032..e0b01b1f 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -206,7 +206,6 @@ def init_kinetic(self, kinetic, backflow):
         self.kinetic_method = kinetic
         if kinetic == "jacobi":
             if backflow is None:
-                self.gradients_jacobi = self.gradients_jacobi_no_backflow
                 self.kinetic_energy = self.kinetic_energy_jacobi
 
             else:
@@ -314,7 +313,7 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         out = self.fc(kin * psi) / self.fc(psi)
         return out
 
-    def gradients_jacobi_no_backflow(self, x, sum_grad=False, pdf=False):
+    def gradients_jacobi(self, x, sum_grad=False, pdf=False):
         """Compute the gradients of the wave function (or density) using the Jacobi Formula
         C. Filippi, Simple Formalism for Efficient Derivatives.
 
@@ -542,7 +541,7 @@ def gradients_jacobi_backflow(self, x, sum_grad=True):
             x ([type]): [description]
         """
         raise NotImplementedError(
-            "Gradient through Jacobi formulat not implemented for backflow orbitals"
+            "Gradient through Jacobi formula not implemented for backflow orbitals"
         )
 
     def log_data(self):
diff --git a/tests/wavefunction/base_test_cases.py b/tests/wavefunction/base_test_cases.py
index 361fad03..2f4e351f 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -135,7 +135,7 @@ def test_kinetic_energy(self):
 
         def test_gradients_wf(self):
 
-            grads = self.wf.gradients_jacobi_no_backflow(
+            grads = self.wf.gradients_jacobi(
                 self.pos, sum_grad=False).squeeze()
             grad_auto = self.wf.gradients_autograd(self.pos)
 
@@ -148,7 +148,7 @@ def test_gradients_wf(self):
 
         def test_gradients_pdf(self):
 
-            grads_pdf = self.wf.gradients_jacobi_no_backflow(self.pos, pdf=True)
+            grads_pdf = self.wf.gradients_jacobi(self.pos, pdf=True)
             grads_auto = self.wf.gradients_autograd(
                 self.pos, pdf=True)
 

From 86f66d662a5c2edb8d99fc0cb905cdc2fc6dd98b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 10:29:33 +0100
Subject: [PATCH 107/286] pylint unused module in baseimport

---
 h5x/baseimport.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 44339111..5c572f82 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,7 +1,7 @@
-from qmctorch.utils.plot_data import (
+from qmctorch.utils.plot_data import ( # pylint: disable=unused-import
     plot_energy, plot_data, plot_block, plot_walkers_traj)
-import matplotlib.pyplot as plt
-import numpy as np
+import matplotlib.pyplot as plt # pylint: disable=unused-import
+import numpy as np # pylint: disable=unused-import
 
 print(r"  ____    __  ______________             _")
 print(r" / __ \  /  |/  / ___/_  __/__  ________/ /  ")

From 3424c6973976caca135b1d60b21855991de2df36 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 13:13:48 +0100
Subject: [PATCH 108/286] fix coday

---
 qmctorch/sampler/hamiltonian.py                      |  2 +-
 qmctorch/sampler/metropolis.py                       |  7 +++++--
 qmctorch/sampler/pints_sampler.py                    |  2 --
 qmctorch/sampler/proposal_kernels.py                 |  8 +-------
 qmctorch/sampler/state_dependent_normal_proposal.py  |  5 -----
 qmctorch/sampler/walkers.py                          |  2 +-
 qmctorch/scf/calculator/adf.py                       |  2 +-
 qmctorch/scf/molecule.py                             |  4 ++--
 qmctorch/solver/solver.py                            |  4 ++--
 qmctorch/solver/solver_base.py                       |  2 --
 qmctorch/solver/solver_mpi.py                        |  7 +++++--
 qmctorch/utils/algebra_utils.py                      |  2 +-
 qmctorch/utils/interpolate.py                        | 12 +++++-------
 qmctorch/utils/plot_data.py                          |  2 +-
 qmctorch/utils/stat_utils.py                         |  2 +-
 qmctorch/wavefunction/__init__.py                    |  9 +--------
 qmctorch/wavefunction/jastrows/combine_jastrow.py    |  1 -
 qmctorch/wavefunction/jastrows/elec_elec/__init__.py |  6 ++++++
 .../kernels/fully_connected_jastrow_kernel.py        |  1 -
 .../kernels/jastrow_kernel_electron_electron_base.py |  3 +--
 .../jastrow_factor_electron_electron_nuclei.py       |  1 -
 .../wavefunction/jastrows/elec_nuclei/__init__.py    |  6 ++++++
 .../elec_nuclei/jastrow_factor_electron_nuclei.py    |  3 ---
 .../jastrows/jastrow_factor_combined_terms.py        |  1 -
 .../orbitals/atomic_orbitals_backflow.py             |  2 +-
 .../atomic_orbitals_orbital_dependent_backflow.py    |  2 +-
 qmctorch/wavefunction/orbitals/backflow/__init__.py  | 10 ++++++++++
 .../orbitals/backflow/backflow_transformation.py     |  1 -
 .../orbitals/backflow/kernels/__init__.py            |  9 +++++++++
 .../backflow/kernels/backflow_kernel_base.py         |  2 +-
 .../kernels/backflow_kernel_fully_connected.py       |  1 -
 .../backflow/kernels/backflow_kernel_power_sum.py    |  1 -
 .../orbital_dependent_backflow_transformation.py     |  1 -
 qmctorch/wavefunction/slater_jastrow.py              |  9 ++++-----
 qmctorch/wavefunction/wf_base.py                     |  5 ++---
 tests/sampler/test_generalized_metropolis.py         |  2 +-
 tests/sampler/test_metropolis.py                     |  4 ++--
 tests/sampler/test_walker.py                         |  8 ++++----
 tests/scf/test_molecule.py                           |  2 +-
 tests/solver/test_base_solver.py                     |  2 +-
 tests/solver/test_h2_adf.py                          | 10 ++--------
 tests/solver/test_lih_correlated.py                  |  2 +-
 tests/wavefunction/orbitals/base_test_ao.py          |  2 +-
 .../orbitals/test_cartesian_harmonics.py             |  2 +-
 .../orbitals/test_cartesian_harmonics_adf.py         |  6 +++---
 tests/wavefunction/orbitals/test_radial_functions.py |  2 +-
 tests/wavefunction/orbitals/test_radial_gto.py       |  2 +-
 tests/wavefunction/orbitals/test_radial_sto.py       |  2 +-
 tests/wavefunction/test_slaterjastrow_generic.py     |  2 +-
 49 files changed, 89 insertions(+), 96 deletions(-)

diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index ce592117..afeef692 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -154,7 +154,7 @@ def _step(U, get_grad, epsilon, L, q_init):
         p -= 0.5 * epsilon * get_grad(U, q)
 
         # full steps in q and p space
-        for iL in range(L - 1):
+        for _ in range(L - 1):
             q += epsilon * p
             p -= epsilon * get_grad(U, q)
 
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 2fda5633..d4ac3ea5 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -259,13 +259,16 @@ def _move(self, num_elec: int) -> torch.Tensor:
             d = torch.rand(
                 (self.walkers.nwalkers, num_elec, self.ndim), device=self.device
             ).view(self.walkers.nwalkers, num_elec * self.ndim)
-            return self.step_size * (2.0 * d - 1.0)
+            out = self.step_size * (2.0 * d - 1.0)
+            return 
 
         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)
+            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
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index a81c03be..3920406c 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -1,9 +1,7 @@
-from tqdm import tqdm
 import torch
 import pints
 from typing import Callable, Union, Dict
 from .sampler_base import SamplerBase
-from .. import log
 
 
 class torch_model(pints.LogPDF):
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index eaa30c2e..c0ddded4 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -1,11 +1,5 @@
-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
 
+import torch
 
 class DensityVarianceKernel(object):
     def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index b70a6a2b..1968e3fa 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -1,10 +1,5 @@
-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 StateDependentNormalProposal(object):
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index c18411c2..f975e1f2 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -5,7 +5,7 @@
 from .. import log
 
 
-class Walkers(object):
+class Walkers():
     def __init__(
         self,
         nwalkers: int = 100,
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index fe5e02f0..33569927 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -187,7 +187,7 @@ def get_basis_data(self, kffile):
         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))
 
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index ba9a07d2..4e6f1de5 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -1,10 +1,9 @@
 import os
-import math
 import numpy as np
 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
@@ -16,6 +15,7 @@
     log.info("  MPI not found.")
 
 
+
 class Molecule:
     def __init__(
         self,
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 11818411..fd68eaf6 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -142,7 +142,7 @@ def freeze_parameters(self, freeze):
                     opt_freeze = ["ci", "mo", "ao", "jastrow"]
                     raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
-    def save_sampling_parameters(self, pos):
+    def save_sampling_parameters(self):
         """save the sampling params."""
         self.sampler._nstep_save = self.sampler.nstep
         self.sampler._ntherm_save = self.sampler.ntherm
@@ -284,7 +284,7 @@ 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.dataloader = DataLoader(pos, batch_size=batchsize, pin_memory=self.cuda)
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index ce5c1f41..29a54092 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,9 +1,7 @@
-from threading import local
 from types import SimpleNamespace
 import os
 import numpy as np
 import torch
-from torch._C import Value
 from tqdm import tqdm
 
 from .. import log
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 7562bc4d..7882b0da 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -198,7 +198,7 @@ def run(
 
         return self.observable
 
-    def single_point(self, with_tqdm=True, hdf5_group="single_point"):
+    def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"):
         """Performs a single point calculation
 
         Args:
@@ -218,6 +218,9 @@ def single_point(self, with_tqdm=True, hdf5_group="single_point"):
             ),
         )
 
+        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":
@@ -230,7 +233,7 @@ def single_point(self, with_tqdm=True, hdf5_group="single_point"):
 
         with grad_mode:
             # sample the wave function
-            pos = self.sampler(self.wf.pdf)
+            pos = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
             if self.wf.cuda and pos.device.type == "cpu":
                 pos = pos.to(self.device)
 
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index a87c7be6..df689ced 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -48,7 +48,7 @@ class BatchDeterminant(torch.autograd.Function):
     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 = (
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index 9f19d833..3670800a 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -17,14 +17,13 @@ def __init__(self, wf):
     def __call__(self, pos, method="irreg", orb="occupied", **kwargs):
         if method == "irreg":
             n = kwargs["n"] if "n" in kwargs else 6
-            return self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
-
+            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.0
-            return self.interpolate_mo_reg_grid(pos, res, blength, orb)
-
+            out =  self.interpolate_mo_reg_grid(pos, res, blength, orb)
+        return out
     def get_mo_max_index(self, orb):
         """Get the index of the highest MO to inlcude in the interpoaltion
 
@@ -302,9 +301,8 @@ def logspace(n, length):
     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
-        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.0, border_length=2.0):
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 10f3b61a..17631d7b 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -222,7 +222,7 @@ def plot_correlation_time(eloc):
         eloc (np.array): values of the local energy
     """
 
-    nstep, nwalkers = eloc.shape
+    nstep, _ = eloc.shape
     max_block_size = nstep // 2
 
     var = np.std(eloc, axis=0)
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 38f2e4bc..81ec69cf 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -68,7 +68,7 @@ def fit_exp(x, y):
         def func(x, tau):
             return np.exp(-x / tau)
 
-        popt, pcov = curve_fit(func, x, y, p0=(1.0))
+        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/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 6078939e..0d1028ef 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -1,14 +1,7 @@
-__all__ = ["WaveFunction", "SlaterJastrow"]
-
 from .wf_base import WaveFunction
 from .slater_jastrow import SlaterJastrow
+from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
 
 __all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
 
-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
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 70fd8ee3..972266be 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index 98540879..4ee206fd 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -4,3 +4,9 @@
 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"]
\ No newline at end of file
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 b9407339..9b24d53b 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,6 +1,5 @@
 import torch
 from torch import nn
-import numpy as np
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
 
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 7203719d..5875b122 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,7 +1,6 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-from torch import nn
 
 
 class JastrowKernelElectronElectronBase(nn.Module):
@@ -66,7 +65,7 @@ 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():
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 3d296aa5..0d0eee9e 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,6 +1,5 @@
 import torch
 from torch import nn
-import torch
 from torch.autograd import Variable, grad
 
 from ..distance.electron_electron_distance import ElectronElectronDistance
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index 226011ff..b54078b9 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -1,3 +1,9 @@
 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"
+]
\ No newline at end of file
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 b376d6ad..db21a73a 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -111,7 +111,6 @@ 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))
             return djast * jast
@@ -131,8 +130,6 @@ 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))
 
diff --git a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
index d2f69a2a..a6b8329c 100644
--- a/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
+++ b/qmctorch/wavefunction/jastrows/jastrow_factor_combined_terms.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from functools import reduce
 
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index b1f124ad..27041475 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -12,7 +12,7 @@ def __init__(self, mol, backflow, cuda=False):
         """
 
         super().__init__(mol, cuda)
-        dtype = torch.get_default_dtype()
+        # dtype = torch.get_default_dtype()
         self.backflow_trans = backflow
 
     def forward(
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
index 50320839..5b87a035 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_orbital_dependent_backflow.py
@@ -16,7 +16,7 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         """
 
         super().__init__(mol, cuda)
-        dtype = torch.get_default_dtype()
+        # dtype = torch.get_default_dtype()
         self.backflow_trans = OrbitalDependentBackFlowTransformation(
             mol,
             backflow_kernel=backflow_kernel,
diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index 7fecfefd..bd4a57b1 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -5,3 +5,13 @@
 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"
+]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 79ed8cee..0bc8f650 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,4 +1,3 @@
-import numpy
 import torch
 from torch import nn
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index 4b96dfc2..e4b9575c 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -4,3 +4,12 @@
 from .backflow_kernel_inverse import BackFlowKernelInverse
 from .backflow_kernel_power_sum import BackFlowKernelPowerSum
 from .backflow_kernel_square import BackFlowKernelSquare
+
+__all__ = [
+    "BackFlowKernelBase",
+    "BackFlowKernelAutoInverse",
+    "BackFlowKernelFullyConnected",
+    "BackFlowKernelInverse",
+    "BackFlowKernelPowerSum",
+    "BackFlowKernelSquare"
+]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index a898b236..4a838bc3 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
+from torch.autograd import grad
 
 
 class BackFlowKernelBase(nn.Module):
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 196da707..9292493f 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -1,6 +1,5 @@
 import torch
 from torch import nn
-from torch.autograd import grad, Variable
 from .backflow_kernel_base import BackFlowKernelBase
 
 
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 925dbd96..053f8eee 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -1,4 +1,3 @@
-import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index b216bc94..18f8f587 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -1,4 +1,3 @@
-import numpy
 import torch
 from torch import nn
 from ...jastrows.distance.electron_electron_distance import ElectronElectronDistance
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index e0b01b1f..6f13b0fc 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -4,6 +4,7 @@
 import numpy as np
 from torch import nn
 import operator
+import matplotlib.pyplot as plt
 
 from .. import log
 
@@ -256,8 +257,8 @@ def forward(self, x, ao=None):
         if self.use_jastrow:
             return J * self.fc(x)
 
-        else:
-            return self.fc(x)
+        # if we do not have a Jastrow
+        return self.fc(x)
 
     def ao2mo(self, ao):
         """transforms AO values in to MO values."""
@@ -643,7 +644,7 @@ def sto(x, norm, alpha):
             # fit AO with STO
             xdata = x.numpy()
             ydata = ao[:, iorb]
-            popt, pcov = curve_fit(sto, xdata, ydata)
+            popt, _ = curve_fit(sto, xdata, ydata)
 
             # store new exp/norm
             basis.bas_norm[iorb] = popt[0]
@@ -662,8 +663,6 @@ def sto(x, norm, alpha):
 
             # plot if necessary
             if plot:
-                import matplotlib.pyplot as plt
-
                 plt.plot(xdata, ydata)
                 plt.plot(xdata, sto(xdata, *popt))
                 plt.show()
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index e0067a71..3f6c7c12 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -213,13 +213,12 @@ def pdf(self, pos, return_grad=False):
         """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):
         """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
diff --git a/tests/sampler/test_generalized_metropolis.py b/tests/sampler/test_generalized_metropolis.py
index 70851a4b..65dc7ec1 100644
--- a/tests/sampler/test_generalized_metropolis.py
+++ b/tests/sampler/test_generalized_metropolis.py
@@ -13,7 +13,7 @@ def test_gmh(self):
             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_metropolis.py b/tests/sampler/test_metropolis.py
index 49ccf446..ed92b590 100644
--- a/tests/sampler/test_metropolis.py
+++ b/tests/sampler/test_metropolis.py
@@ -22,7 +22,7 @@ def test_metropolis(self):
             for p in ['normal', 'uniform']:
 
                 sampler.configure_move({'type': m, 'proba': p})
-                pos = sampler(self.wf.pdf)
+                _ = sampler(self.wf.pdf)
 
     def test_metropolis_logspace(self):
         """Test Metropolis sampling in logspace."""
@@ -40,7 +40,7 @@ def test_metropolis_logspace(self):
             for p in ['normal', 'uniform']:
 
                 sampler.configure_move({'type': m, 'proba': p})
-                pos = sampler(self.wf.pdf)
+                _ = sampler(self.wf.pdf)
 
 
 if __name__ == "__main__":
diff --git a/tests/sampler/test_walker.py b/tests/sampler/test_walker.py
index 3554311b..f05b0637 100644
--- a/tests/sampler/test_walker.py
+++ b/tests/sampler/test_walker.py
@@ -8,19 +8,19 @@ class TestWalkers(TestSamplerBase):
 
     def test_walkers_init(self):
         """Test different initialization methods of the walkers."""
-        w1 = Walkers(nwalkers=10,
+        _ = Walkers(nwalkers=10,
                      nelec=self.mol.nelec, ndim=3,
                      init=self.mol.domain('center'))
 
-        w2 = Walkers(nwalkers=10,
+        _ = Walkers(nwalkers=10,
                      nelec=self.mol.nelec, ndim=3,
                      init=self.mol.domain('uniform'))
 
-        w3 = Walkers(nwalkers=10,
+        _ = Walkers(nwalkers=10,
                      nelec=self.mol.nelec, ndim=3,
                      init=self.mol.domain('normal'))
 
-        w4 = Walkers(nwalkers=10,
+        _ = Walkers(nwalkers=10,
                      nelec=self.mol.nelec, ndim=3,
                      init=self.mol.domain('atomic'))
 
diff --git a/tests/scf/test_molecule.py b/tests/scf/test_molecule.py
index 6ae26223..ad52b8a7 100644
--- a/tests/scf/test_molecule.py
+++ b/tests/scf/test_molecule.py
@@ -19,7 +19,7 @@ def test1_create(self):
         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')
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 54d16c6e..23e77b56 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -20,7 +20,7 @@ def test1_single_point(self):
 
             # sample and compute observables
             obs = self.solver.single_point()
-            e, v = obs.energy, obs.variance
+            _, _ = obs.energy, obs.variance
 
             # if self.expected_energy is not None:
             #     assert(
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index aabaf28e..426cdae2 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -1,20 +1,14 @@
-from ..path_utils import PATH_TEST
 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
-import unittest
-
+from qmctorch.solver import Solver
 
+import unittest
 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 import SlaterJastrow
-
 from ..path_utils import PATH_TEST
 
 
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index 5ceceafc..fddc809e 100644
--- a/tests/solver/test_lih_correlated.py
+++ b/tests/solver/test_lih_correlated.py
@@ -91,7 +91,7 @@ def test3_wf_opt_grad_manual(self):
 
         self.solver.configure(track=['local_energy'],
                               loss='energy', grad='manual')
-        obs = self.solver.run(5)
+        _ = self.solver.run(5)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index fa1c9f8f..3bfad9ed 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -73,7 +73,7 @@ class BaseTestAOderivatives(unittest.TestCase):
 
         def setUp(self):
 
-            def ao_callable(pos):
+            def ao_callable(pos, derivative=0, sum_grad=False):
                 """Callable for the AO"""
                 return None
             self.ao = ao_callable
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics.py b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
index 7614c1c1..20b856fd 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -98,7 +98,7 @@ def process_position(self):
         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):
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
index 0280b0d1..72d86d0a 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -31,7 +31,7 @@ def test_first_derivative_x(self):
         self.pos[:, 0] = torch.linspace(-4, 4, npts)
         self.dx = self.pos[1, 0] - self.pos[0, 0]
 
-        xyz, r = self.ao._process_position(self.pos)
+        xyz, _ = self.ao._process_position(self.pos)
         R, dR = self.ao.harmonics(
             xyz, derivative=[0, 1], sum_grad=False)
 
@@ -130,8 +130,8 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 13] = -eps
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
-        xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.harmonics(
+        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):
diff --git a/tests/wavefunction/orbitals/test_radial_functions.py b/tests/wavefunction/orbitals/test_radial_functions.py
index a722a88f..eca5542d 100644
--- a/tests/wavefunction/orbitals/test_radial_functions.py
+++ b/tests/wavefunction/orbitals/test_radial_functions.py
@@ -101,7 +101,7 @@ def process_position(self):
 
     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)
 
diff --git a/tests/wavefunction/orbitals/test_radial_gto.py b/tests/wavefunction/orbitals/test_radial_gto.py
index 19aef652..fc563ed2 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -138,7 +138,7 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = z
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(r, self.ao.bas_n,
+        R, _, d2R = self.ao.radial(r, self.ao.bas_n,
                                     self.ao.bas_exp,
                                     xyz=xyz,
                                     derivative=[0, 1, 2],
diff --git a/tests/wavefunction/orbitals/test_radial_sto.py b/tests/wavefunction/orbitals/test_radial_sto.py
index 91f74f58..d4b2fb83 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -140,7 +140,7 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, r = self.ao._process_position(self.pos)
-        R, dR, d2R = self.ao.radial(r, self.ao.bas_n,
+        R, _, d2R = self.ao.radial(r, self.ao.bas_n,
                                     self.ao.bas_exp,
                                     xyz=xyz,
                                     derivative=[0, 1, 2],
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 66fbdacf..b8d8a40e 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -50,7 +50,7 @@ def setUp(self):
                                 include_all_mo=False,
                                 configs='single_double(2,2)',
                                 jastrow=jastrow,
-                                backflow=None)
+                                backflow=backflow)
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)
         self.wf.fc.weight.data = self.random_fc_weight

From 903c148365b51767ad5faa35f5c090c3cfa41cdf Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 13:14:57 +0100
Subject: [PATCH 109/286] black formatting

---
 tests/path_utils.py                           |   2 +-
 tests/sampler/test_generalized_metropolis.py  |  11 +-
 tests/sampler/test_hamiltonian.py             |   4 +-
 tests/sampler/test_metropolis.py              |  23 ++--
 tests/sampler/test_metropolis_hasting.py      |  16 ++-
 tests/sampler/test_pints.py                   |  11 +-
 tests/sampler/test_sampler_base.py            |  18 +--
 tests/sampler/test_walker.py                  |  25 ++--
 tests/scf/test_gto2sto_fit.py                 |  55 ++++----
 tests/scf/test_molecule.py                    |  55 ++++----
 tests/solver/test_base_solver.py              |  16 +--
 tests/solver/test_h2_adf.py                   |  27 ++--
 tests/solver/test_h2_adf_jacobi.py            |  26 ++--
 tests/solver/test_h2_pyscf_geo_opt.py         |  44 +++---
 tests/solver/test_h2_pyscf_hamiltonian.py     |  29 ++--
 tests/solver/test_h2_pyscf_jacobi.py          |  29 ++--
 tests/solver/test_h2_pyscf_metropolis.py      |  50 +++----
 tests/solver/test_h2_pyscf_stats.py           |  39 +++---
 tests/solver/test_lih_adf_backflow.py         |  42 +++---
 tests/solver/test_lih_correlated.py           |  34 ++---
 tests/solver/test_lih_pyscf.py                |  31 ++---
 tests/solver/test_lih_pyscf_backflow.py       |  48 ++++---
 .../solver/test_lih_pyscf_compare_backflow.py | 125 +++++++++---------
 .../solver/test_lih_pyscf_generic_backflow.py |  48 ++++---
 .../solver/test_lih_pyscf_generic_jastrow.py  |  40 +++---
 ...st_lih_pyscf_orbital_dependent_backflow.py |  48 ++++---
 tests/utils/test_interpolate.py               |  36 +++--
 tests/wavefunction/base_test_cases.py         | 112 +++++++---------
 .../distance/test_elec_elec_distance.py       |  21 +--
 .../elec_elec/base_elec_elec_jastrow_test.py  |  66 +++------
 .../elec_elec/test_generic_jastrow.py         |  17 ++-
 .../jastrows/elec_elec/test_pade_jastrow.py   |  15 ++-
 .../elec_elec/test_pade_jastrow_polynom.py    |  23 ++--
 .../elec_elec/test_scaled_pade_jastrow.py     |  16 +--
 .../test_scaled_pade_jastrow_polynom.py       |  25 ++--
 .../jastrows/elec_elec_nuc/test_hess.py       |  16 +--
 .../test_three_body_jastrow_boys_handy.py     |  83 +++++-------
 ...test_three_body_jastrow_fully_connected.py |  77 ++++-------
 .../test_electron_nuclei_fully_connected.py   |  54 +++-----
 .../test_electron_nuclei_pade_jastrow.py      |  54 +++-----
 .../jastrows/graph/test_graph_jastrow.py      |  80 ++++-------
 .../jastrows/test_combined_terms.py           |  64 ++++-----
 .../test_backflow_kernel_generic_pyscf.py     | 104 ++++++---------
 .../test_backflow_kernel_inverse_pyscf.py     |  96 ++++++--------
 .../test_backflow_transformation_pyscf.py     |  55 +++-----
 ...dependent_backflow_transformation_pyscf.py |  65 ++++-----
 tests/wavefunction/orbitals/base_test_ao.py   |  74 ++++-------
 .../orbitals/second_derivative.py             |   1 -
 .../orbitals/test_ao_derivatives_adf.py       |   5 +-
 .../orbitals/test_ao_derivatives_pyscf.py     |  12 +-
 .../orbitals/test_ao_values_adf.py            |  60 ++++-----
 .../orbitals/test_ao_values_pyscf.py          |  35 ++---
 .../test_backflow_ao_derivatives_pyscf.py     |  77 +++++------
 .../orbitals/test_cartesian_harmonics.py      |  73 ++++------
 .../orbitals/test_cartesian_harmonics_adf.py  |  57 +++-----
 .../orbitals/test_mo_values_adf.py            |  51 ++++---
 tests/wavefunction/orbitals/test_norm.py      |  21 ++-
 ...dependent_backflow_ao_derivatives_pyscf.py |  77 +++++------
 .../orbitals/test_radial_functions.py         | 118 +++++++----------
 .../wavefunction/orbitals/test_radial_gto.py  |  96 +++++++-------
 .../wavefunction/orbitals/test_radial_sto.py  |  94 +++++++------
 .../orbitals/test_spherical_harmonics.py      |   3 +-
 tests/wavefunction/pooling/test_orbconf.py    |  20 ++-
 tests/wavefunction/pooling/test_slater.py     |  57 ++++----
 .../wavefunction/pooling/test_trace_trick.py  | 114 ++++++++--------
 .../test_compare_slaterjastrow_backflow.py    |  88 ++++++------
 ...laterjastrow_orbital_dependent_backflow.py |  81 ++++++------
 .../test_slater_mgcn_graph_jastrow.py         | 119 ++++++++---------
 .../test_slatercombinedjastrow.py             |  62 +++++----
 .../test_slatercombinedjastrow_backflow.py    |  77 ++++++-----
 .../test_slatercombinedjastrow_internal.py    |  38 +++---
 tests/wavefunction/test_slaterjastrow.py      |  38 +++---
 .../test_slaterjastrow_backflow.py            |  41 +++---
 tests/wavefunction/test_slaterjastrow_cas.py  |  35 ++---
 .../test_slaterjastrow_ee_cusp.py             |  59 +++++----
 .../test_slaterjastrow_generic.py             |  48 ++++---
 ...laterjastrow_orbital_dependent_backflow.py |  56 ++++----
 77 files changed, 1700 insertions(+), 2062 deletions(-)

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 65dc7ec1..46a57e87 100644
--- a/tests/sampler/test_generalized_metropolis.py
+++ b/tests/sampler/test_generalized_metropolis.py
@@ -5,13 +5,16 @@
 
 
 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"),
+        )
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_hamiltonian.py b/tests/sampler/test_hamiltonian.py
index 88b866a3..8ffb7c8d 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,7 +13,8 @@ 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)
 
diff --git a/tests/sampler/test_metropolis.py b/tests/sampler/test_metropolis.py
index ed92b590..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,12 +15,12 @@ def test_metropolis(self):
             step_size=0.5,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
-
-        for m in ['one-elec', 'all-elec', 'all-elec-iter']:
-            for p in ['normal', 'uniform']:
+            init=self.mol.domain("normal"),
+        )
 
-                sampler.configure_move({'type': m, 'proba': p})
+        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)
 
     def test_metropolis_logspace(self):
@@ -33,13 +32,13 @@ def test_metropolis_logspace(self):
             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']:
+            init=self.mol.domain("normal"),
+            logspace=True,
+        )
 
-                sampler.configure_move({'type': m, 'proba': p})
+        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)
 
 
diff --git a/tests/sampler/test_metropolis_hasting.py b/tests/sampler/test_metropolis_hasting.py
index f8a1c007..e9a2206d 100644
--- a/tests/sampler/test_metropolis_hasting.py
+++ b/tests/sampler/test_metropolis_hasting.py
@@ -1,11 +1,13 @@
 import unittest
 from qmctorch.sampler import MetropolisHasting
-from qmctorch.sampler.proposal_kernels import ConstantVarianceKernel, CenterVarianceKernel
+from qmctorch.sampler.proposal_kernels import (
+    ConstantVarianceKernel,
+    CenterVarianceKernel,
+)
 from .test_sampler_base import TestSamplerBase
 
 
 class TestMetropolisHasting(TestSamplerBase):
-
     def test_ConstantKernel(self):
         """Test Metropolis sampling."""
 
@@ -14,8 +16,9 @@ def test_ConstantKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            kernel=ConstantVarianceKernel())
+            init=self.mol.domain("normal"),
+            kernel=ConstantVarianceKernel(),
+        )
 
         _ = sampler(self.wf.pdf)
 
@@ -27,8 +30,9 @@ def test_CenterVarianceKernel(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            kernel=CenterVarianceKernel())
+            init=self.mol.domain("normal"),
+            kernel=CenterVarianceKernel(),
+        )
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_pints.py b/tests/sampler/test_pints.py
index a4c2674e..6bb11e35 100644
--- a/tests/sampler/test_pints.py
+++ b/tests/sampler/test_pints.py
@@ -7,7 +7,6 @@
 
 
 class TestPints(TestSamplerBase):
-
     def test_Haario(self):
         """Test Metropolis sampling."""
 
@@ -16,8 +15,9 @@ def test_Haario(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
-            method=pints.HaarioBardenetACMC)
+            init=self.mol.domain("normal"),
+            method=pints.HaarioBardenetACMC,
+        )
 
         _ = sampler(self.wf.pdf)
 
@@ -29,9 +29,10 @@ def test_Langevin(self):
             nstep=20,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'),
+            init=self.mol.domain("normal"),
             method=pints.MALAMCMC,
-            method_requires_grad=True)
+            method_requires_grad=True,
+        )
 
         _ = sampler(self.wf.pdf)
 
diff --git a/tests/sampler/test_sampler_base.py b/tests/sampler/test_sampler_base.py
index b29547b1..37862707 100644
--- a/tests/sampler/test_sampler_base.py
+++ b/tests/sampler/test_sampler_base.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestSamplerBase(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,13 +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)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # orbital
         self.wf = SlaterJastrow(self.mol, jastrow=jastrow)
diff --git a/tests/sampler/test_walker.py b/tests/sampler/test_walker.py
index f05b0637..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."""
-        _ = 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")
+        )
 
-        _ = 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")
+        )
 
-        _ = 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")
+        )
 
-        _ = 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 31f39f4d..9392faa0 100644
--- a/tests/scf/test_gto2sto_fit.py
+++ b/tests/scf/test_gto2sto_fit.py
@@ -7,14 +7,14 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 class TestGTO2STOFit(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -22,36 +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,
+        )
 
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol, kinetic='auto',
-                                configs='ground_state', jastrow=jastrow).gto2sto()
+        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 = -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 ad52b8a7..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):
-        _ = 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
index 23e77b56..6e97354c 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,11 +1,8 @@
 import unittest
 
 
-
 class BaseTestSolvers:
-
     class BaseTestSolverMolecule(unittest.TestCase):
-
         def setUp(self):
             self.mol = None
             self.wf = None
@@ -17,7 +14,6 @@ def setUp(self):
             self.expected_variance = None
 
         def test1_single_point(self):
-
             # sample and compute observables
             obs = self.solver.single_point()
             _, _ = obs.energy, obs.variance
@@ -31,13 +27,13 @@ def test1_single_point(self):
             #         np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
 
         def test2_wf_opt_grad_auto(self):
-
-            self.solver.configure(track=['local_energy', 'parameters'],
-                                  loss='energy', grad='auto')
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="auto"
+            )
             _ = self.solver.run(5)
 
         def test3_wf_opt_grad_manual(self):
-
-            self.solver.configure(track=['local_energy', 'parameters'],
-                                  loss='energy', grad='manual')
+            self.solver.configure(
+                track=["local_energy", "parameters"], loss="energy", grad="manual"
+            )
             _ = self.solver.run(5)
diff --git a/tests/solver/test_h2_adf.py b/tests/solver/test_h2_adf.py
index 426cdae2..1711ec96 100644
--- a/tests/solver/test_h2_adf.py
+++ b/tests/solver/test_h2_adf.py
@@ -13,23 +13,20 @@
 
 
 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)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -38,24 +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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1572532653808594,
-                                -1.1501641653648578]
+        self.expected_energy = [-1.1572532653808594, -1.1501641653648578]
 
-        self.expected_variance = [0.05085879936814308,
-                                  0.05094174843043177]
+        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 e2118c3f..0d9e4c35 100644
--- a/tests/solver/test_h2_adf_jacobi.py
+++ b/tests/solver/test_h2_adf_jacobi.py
@@ -13,21 +13,19 @@
 
 
 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)', jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -36,24 +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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # vals on different archs
-        self.expected_energy = [-1.1571345329284668,
-                                -1.1501641653648578]
+        self.expected_energy = [-1.1571345329284668, -1.1501641653648578]
 
-        self.expected_variance = [0.05087674409151077,
-                                  0.05094174843043177]
+        self.expected_variance = [0.05087674409151077, 0.05094174843043177]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index 31466dd0..8b165e17 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -15,9 +15,7 @@
 
 
 class TestH2GeoOpt(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -27,19 +25,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -48,31 +46,25 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
     def test_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.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.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.load(self.solver.hdf5file, "geo_opt")
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -84,8 +76,8 @@ def test_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert(e > 2 * gse and e < 0.)
-        assert(v > 0 and v < 2.)
+        assert e > 2 * gse and e < 0.0
+        assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_hamiltonian.py b/tests/solver/test_h2_pyscf_hamiltonian.py
index d02680d3..3c20711f 100644
--- a/tests/solver/test_h2_pyscf_hamiltonian.py
+++ b/tests/solver/test_h2_pyscf_hamiltonian.py
@@ -17,9 +17,7 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -29,18 +27,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -48,22 +47,20 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        self.expected_energy = [-1.0877732038497925, -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        self.expected_variance = [0.14341972768306732, 0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_jacobi.py b/tests/solver/test_h2_pyscf_jacobi.py
index 6951f435..f7702dc8 100644
--- a/tests/solver/test_h2_pyscf_jacobi.py
+++ b/tests/solver/test_h2_pyscf_jacobi.py
@@ -17,9 +17,7 @@
 
 
 class TestH2SamplerHMC(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -29,18 +27,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)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         self.sampler = Hamiltonian(
             nwalkers=100,
@@ -48,22 +47,20 @@ def setUp(self):
             step_size=0.1,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('normal'))
+            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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.0877732038497925,
-                                -1.088576]
+        self.expected_energy = [-1.0877732038497925, -1.088576]
 
         # values on different arch
-        self.expected_variance = [0.14341972768306732,
-                                  0.163771]
+        self.expected_variance = [0.14341972768306732, 0.163771]
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index ea407fb9..49d2f174 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -17,9 +17,7 @@
 
 
 class TestH2SamplerMH(BaseTestSolvers.BaseTestSolverMolecule):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -29,19 +27,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='auto',
-                                configs='single(2,2)',
-                                jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="auto", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -50,39 +48,31 @@ 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)
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
         # values on different arch
-        self.expected_energy = [-1.1464850902557373,
-                                -1.14937478612449]
+        self.expected_energy = [-1.1464850902557373, -1.14937478612449]
 
         # values on different arch
-        self.expected_variance = [0.9279592633247375,
-                                  0.7445300449383236]
+        self.expected_variance = [0.9279592633247375, 0.7445300449383236]
 
     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.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.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.load(self.solver.hdf5file, "geo_opt")
         self.solver.wf.eval()
 
         # sample and compute variables
@@ -94,8 +84,8 @@ def test4_geo_opt(self):
 
         # it might be too much to assert with the ground state energy
         gse = -1.16
-        assert(e > 2 * gse and e < 0.)
-        assert(v > 0 and v < 2.)
+        assert e > 2 * gse and e < 0.0
+        assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_stats.py b/tests/solver/test_h2_pyscf_stats.py
index 76f77ddd..1cecf465 100644
--- a/tests/solver/test_h2_pyscf_stats.py
+++ b/tests/solver/test_h2_pyscf_stats.py
@@ -6,19 +6,20 @@
 
 from qmctorch.sampler import Metropolis
 from qmctorch.solver import Solver
-from qmctorch.utils.plot_data 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.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)
 
@@ -28,17 +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)', jastrow=jastrow)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="single(2,2)", jastrow=jastrow
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -49,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)
 
@@ -70,7 +70,6 @@ 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)
 
diff --git a/tests/solver/test_lih_adf_backflow.py b/tests/solver/test_lih_adf_backflow.py
index ec91a8ff..606ed2b4 100644
--- a/tests/solver/test_lih_adf_backflow.py
+++ b/tests/solver/test_lih_adf_backflow.py
@@ -8,7 +8,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -17,16 +20,13 @@
 
 
 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
@@ -34,21 +34,26 @@ def setUp(self):
 
         # backflow
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=False)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -57,22 +62,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_correlated.py b/tests/solver/test_lih_correlated.py
index fddc809e..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,8 +78,7 @@ 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')
+        self.solver.configure(track=["local_energy"], loss="energy", grad="manual")
         _ = self.solver.run(5)
 
 
diff --git a/tests/solver/test_lih_pyscf.py b/tests/solver/test_lih_pyscf.py
index e287934c..20be58b7 100644
--- a/tests/solver/test_lih_pyscf.py
+++ b/tests/solver/test_lih_pyscf.py
@@ -14,26 +14,29 @@
 
 
 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')
+            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)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -42,17 +45,15 @@ 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)
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_lih_pyscf_backflow.py b/tests/solver/test_lih_pyscf_backflow.py
index 0d6f13ff..fe15c965 100644
--- a/tests/solver/test_lih_pyscf_backflow.py
+++ b/tests/solver/test_lih_pyscf_backflow.py
@@ -8,7 +8,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -16,40 +19,44 @@
 
 
 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -58,22 +65,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_compare_backflow.py b/tests/solver/test_lih_pyscf_compare_backflow.py
index 0f97b992..0ce23238 100644
--- a/tests/solver/test_lih_pyscf_compare_backflow.py
+++ b/tests/solver/test_lih_pyscf_compare_backflow.py
@@ -9,7 +9,10 @@
 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
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.utils import set_torch_double_precision
 
 
@@ -19,49 +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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # backflow wave function
-        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.
+        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, jastrow=jastrow_ref, backflow=None,
-                                    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)
@@ -70,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
@@ -83,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(
@@ -95,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()
@@ -108,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)
@@ -131,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()
@@ -153,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 c7fdffad..89a67a31 100644
--- a/tests/solver/test_lih_pyscf_generic_backflow.py
+++ b/tests/solver/test_lih_pyscf_generic_backflow.py
@@ -8,7 +8,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelPowerSum
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelPowerSum,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -16,40 +19,44 @@
 
 
 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)
+            self.mol, BackFlowKernelPowerSum, orbital_dependent=False
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -58,22 +65,19 @@ 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
 
 
diff --git a/tests/solver/test_lih_pyscf_generic_jastrow.py b/tests/solver/test_lih_pyscf_generic_jastrow.py
index c76ba7ce..c43e3564 100644
--- a/tests/solver/test_lih_pyscf_generic_jastrow.py
+++ b/tests/solver/test_lih_pyscf_generic_jastrow.py
@@ -8,35 +8,40 @@
 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.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')
+            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)
+        self.wf = SlaterJastrow(
+            self.mol,
+            kinetic="jacobi",
+            configs="single(2,2)",
+            include_all_mo=False,
+            jastrow=jastrow,
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -45,22 +50,19 @@ 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 test2_wf_opt_grad_auto(self):
diff --git a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
index b1ad4faf..3bdd156f 100644
--- a/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
+++ b/tests/solver/test_lih_pyscf_orbital_dependent_backflow.py
@@ -8,7 +8,10 @@
 from qmctorch.solver import Solver
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.utils import set_torch_double_precision
 
@@ -16,40 +19,44 @@
 
 
 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                jastrow=jastrow,
-                                backflow=backflow,
-                                configs='single_double(2,2)',
-                                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(
@@ -58,22 +65,19 @@ 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
 
 
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index 6a74199f..b8229b52 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -2,60 +2,54 @@
 
 import torch
 
-from qmctorch.utils import (InterpolateAtomicOrbitals,
-                            InterpolateMolecularOrbitals)
+from qmctorch.utils import InterpolateAtomicOrbitals, InterpolateMolecularOrbitals
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
 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)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='single(2,2)', jastrow=jastrow)
+        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')
+        inter = interp_mo(self.pos, method="reg")
         ref = self.wf.mo(self.wf.mo_scf(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')
+        inter = interp_mo(self.pos, method="irreg")
         ref = self.wf.mo(self.wf.mo_scf(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
index 2f4e351f..7f7144b7 100644
--- a/tests/wavefunction/base_test_cases.py
+++ b/tests/wavefunction/base_test_cases.py
@@ -7,21 +7,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]
 
@@ -29,16 +24,14 @@ def hess(out, pos):
 
 
 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
@@ -54,8 +47,10 @@ def test_antisymmetry(self):
 
             if self.wf.nelec < 4:
                 print(
-                    'Warning : antisymmetry cannot be tested with \
-                        only %d electrons' % self.wf.nelec)
+                    "Warning : antisymmetry cannot be tested with \
+                        only %d electrons"
+                    % self.wf.nelec
+                )
                 return
 
             # test spin up
@@ -64,23 +59,21 @@ def test_antisymmetry(self):
             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)
+            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))
+            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
+            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)
+            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))
+            assert torch.allclose(wfvals_ref, -1 * wfvals_xdn)
 
         def test_grad_mo(self):
             """Gradients of the MOs."""
@@ -88,16 +81,14 @@ def test_grad_mo(self):
             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]
+            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)))
+            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."""
@@ -106,71 +97,62 @@ def test_hess_mo(self):
             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(), 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).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)))
+            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)
+            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)
+            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()
+            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))
+            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)
+            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()))
+            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 = 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))
+            assert torch.allclose(psum_mo, psum_mo_grad)
 
         def test_grad_mo(self):
             """Gradients of the BF MOs."""
@@ -180,15 +162,13 @@ def test_grad_mo(self):
             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_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))
+            assert torch.allclose(dmo, dmo_grad)
 
         def test_hess_mo(self):
             """Hessian of the MOs."""
@@ -198,14 +178,12 @@ def test_hess_mo(self):
             d2ao = self.wf.ao(self.pos, derivative=2, sum_hess=False)
             d2val = self.wf.ao2mo(d2ao)
 
-            assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+            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 = 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))
+            assert torch.allclose(d2val, d2val_grad)
 
         def test_gradients_wf(self):
             pass
diff --git a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
index 6024fb77..a84f1fee 100644
--- a/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
+++ b/tests/wavefunction/jastrows/distance/test_elec_elec_distance.py
@@ -9,21 +9,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]
 
@@ -31,7 +26,6 @@ def hess(out, pos):
 
 
 class TestElecElecDistance(unittest.TestCase):
-
     def setUp(self):
         self.nup, self.ndown = 1, 1
         self.nelec = self.nup + self.ndown
@@ -72,15 +66,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/base_elec_elec_jastrow_test.py b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
index 59703ffd..cdc90d2a 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -7,21 +7,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]
 
@@ -29,16 +24,14 @@ def hess(out, pos):
 
 
 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 
-            
+                return None
+
             self.jastrow = jastrow_callable
             self.nbatch = None
             self.pos = None
@@ -48,7 +41,6 @@ def test_jastrow(self):
             val = self.jastrow(self.pos)
 
         def test_permutation(self):
-
             jval = self.jastrow(self.pos)
 
             # test spin up
@@ -57,64 +49,48 @@ def test_permutation(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)
 
             jval_xup = self.jastrow(pos_xup)
-            assert(torch.allclose(jval, jval_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]
+            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_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 = 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_grad_jastrow(self):
-
             val = self.jastrow(self.pos)
-            dval = self.jastrow(
-                self.pos, derivative=1, sum_grad=False)
+            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 = 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, dval_grad.transpose(1, 2))
-            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, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2)
+            )
 
-            assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+            assert torch.allclose(d2val.sum(), d2val_grad.sum())
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index ef8fa1cc..dc9d78a3 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -7,28 +6,28 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.fully_connected_jastrow_kernel import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestGenericJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
         mol = SimpleNamespace(nup=4, ndown=4)
         self.nelec = mol.nup + mol.ndown
 
-        self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            FullyConnectedJastrowKernel)
+        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
 
 
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 7bb0a1da..4f6fd241 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -5,16 +5,18 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -22,9 +24,8 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            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)
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 13a33a17..43dc6135 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -8,16 +7,18 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import (
+    PadeJastrowPolynomialKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -25,10 +26,14 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, 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)
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 4d7bdbcf..9dca1be1 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -5,16 +5,18 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrow(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -22,10 +24,8 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol,
-            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)
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 626d7535..d6f29843 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,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -8,16 +7,18 @@
 
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
+from qmctorch.wavefunction.jastrows.elec_elec.kernels.pade_jastrow_polynomial_kernel import (
+    PadeJastrowPolynomialKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestScaledPadeJastrowPolynom(BaseTestJastrow.ElecElecJastrowBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -25,11 +26,15 @@ def setUp(self):
         self.nelec = mol.nup + mol.ndown
 
         self.jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowPolynomialKernel,
-            kernel_kwargs={'order': 5,
-                           'weight_a': 0.1*torch.ones(5),
-                           'weight_b': 0.1*torch.ones(5)},
-            scale=True)
+            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)
diff --git a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
index 76e07580..800bce94 100644
--- a/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
+++ b/tests/wavefunction/jastrows/elec_elec_nuc/test_hess.py
@@ -14,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 5e903dab..33a50cb6 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
+    BoysHandyJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,55 +33,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*np.random.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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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
@@ -91,54 +81,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 91e7accc..5f693bae 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,92 +33,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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronElectronNuclei(
-            self.mol, 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/test_electron_nuclei_fully_connected.py b/tests/wavefunction/jastrows/elec_nuc/test_electron_nuclei_fully_connected.py
index f019dcbc..1d793868 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
@@ -3,8 +3,12 @@
 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 import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
+    JastrowFactorElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    FullyConnectedJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -12,21 +16,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]
 
@@ -34,9 +33,7 @@ def hess(out, pos):
 
 
 class TestElectronNucleiGeneric(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -44,50 +41,41 @@ def setUp(self):
         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)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
         self.jastrow = JastrowFactorElectronNuclei(
-            self.mol, 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 832beb5d..e9f995b2 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
@@ -4,8 +4,12 @@
 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.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
+    JastrowFactorElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels.pade_jastrow_kernel import (
+    PadeJastrowKernel,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -13,21 +17,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,9 +34,7 @@ def hess(out, pos):
 
 
 class TestElectronNucleiPadeJastrow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -45,51 +42,40 @@ def setUp(self):
         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.mol, PadeJastrowKernel)
+            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/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index a9bb3d1b..67ac08ab 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -12,21 +12,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]
 
@@ -34,9 +29,7 @@ def hess(out, pos):
 
 
 class TestGraphJastrow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -45,29 +38,27 @@ def setUp(self):
         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 = JastrowFactorGraph(self.mol,
-                                          ee_model=MGCNPredictor,
-                                          ee_model_kwargs={'n_layers': 3,
-                                                           'feats': 32,
-                                                           'cutoff': 5.0,
-                                                           'gap': 1.},
-                                          en_model=MGCNPredictor,
-                                          en_model_kwargs={'n_layers': 3,
-                                                           'feats': 32,
-                                                           'cutoff': 5.0,
-                                                           'gap': 1.0})
+        self.mol = SimpleNamespace(
+            nup=self.nup,
+            ndown=self.ndown,
+            atom_coords=self.atomic_pos,
+            atoms=self.atom_types,
+        )
+
+        self.jastrow = JastrowFactorGraph(
+            self.mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
 
         self.nbatch = 5
 
-        self.pos = -1. + 2*torch.rand(self.nbatch, self.nelec * 3)
+        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
@@ -76,54 +67,41 @@ def test_permutation(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)
 
         jval_xup = self.jastrow(pos_xup)
-        assert(torch.allclose(jval, jval_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 = 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_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, dval_grad.transpose(1, 2))
-        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, d2val_grad.view(self.nbatch, self.nelec, 3).sum(2))
 
-        assert(torch.allclose(d2val.sum(), d2val_grad.sum()))
+        assert torch.allclose(d2val.sum(), d2val_grad.sum())
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index 3283bd9c..56b6da71 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -4,10 +4,18 @@
 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
+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,
+)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -15,21 +23,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]
 
@@ -37,9 +40,7 @@ def hess(out, pos):
 
 
 class TestJastrowCombinedTerms(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -48,20 +49,18 @@ def setUp(self):
         self.atoms = np.random.rand(4, 3)
 
         self.mol = SimpleNamespace(
-            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms)
+            nup=self.nup, ndown=self.ndown, atom_coords=self.atoms
+        )
 
         self.jastrow = JastrowFactorCombinedTerms(
             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
 
@@ -72,30 +71,23 @@ def test_jastrow(self):
         val = 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/test_backflow_kernel_generic_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
index 19d444a4..3cd36905 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -7,7 +7,10 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
+from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import (
+    ElectronElectronDistance,
+)
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -15,24 +18,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]
 
@@ -40,36 +37,29 @@ 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 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:
@@ -87,16 +77,11 @@ def _backflow_kernel(self, ree):
 
 
 class TestGenericBackFlowKernel(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 kernel
         self.kernel = GenericBackFlowKernel(self.mol)
@@ -110,20 +95,21 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
+        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_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))
+        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."""
+        wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -132,8 +118,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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))
+        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.
@@ -155,8 +141,7 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
+        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
@@ -169,16 +154,14 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
+        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))
+        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.
@@ -205,29 +188,30 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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()))
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
 
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
+        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
 
 
 if __name__ == "__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 4f6980ed..6a851d66 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -6,7 +6,10 @@
 
 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.wavefunction.jastrows.distance.electron_electron_distance import (
+    ElectronElectronDistance,
+)
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -14,24 +17,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]
 
@@ -39,39 +36,27 @@ 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 TestBackFlowKernel(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 kernel
         self.kernel = BackFlowKernelInverse(self.mol)
@@ -85,20 +70,21 @@ def setUp(self):
 
     def test_derivative_backflow_kernel(self):
         """Test the derivative of the kernel function
-            wrt the elec-elec distance."""
+        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_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))
+        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."""
+        wrt the elec-elec distance."""
 
         ree = self.edist(self.pos)
         bf_kernel = self.kernel(ree)
@@ -107,8 +93,8 @@ def test_second_derivative_backflow_kernel(self):
 
         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))
+        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.
@@ -130,8 +116,7 @@ def test_derivative_backflow_kernel_pos(self):
         dj_ree = di_ree
 
         # compute the derivative of the kernal values
-        bf_der = self.kernel(
-            ree, derivative=1)
+        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
@@ -144,16 +129,14 @@ def test_derivative_backflow_kernel_pos(self):
         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]
+        dbfpos_grad = grad(bfpos, self.pos, grad_outputs=torch.ones_like(bfpos))[0]
 
         # checksum
-        assert(torch.allclose(d_bfpos.sum(), dbfpos_grad.sum()))
+        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))
+        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.
@@ -180,29 +163,30 @@ def test_second_derivative_backflow_kernel_pos(self):
         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).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=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).unsqueeze(1) * d2i_ree
 
-        d2bf_kernel += self.kernel(
-            ree, derivative=1).permute(0, 2, 1).unsqueeze(1) * d2j_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()))
+        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)
+        d2bf_kernel = d2bf_kernel.sum(-1).permute(0, 2, 1).reshape(self.npts, -1)
 
-        assert(torch.allclose(d2bf_kernel, d2bf_kernel_auto))
+        assert torch.allclose(d2bf_kernel, d2bf_kernel_auto)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index a649f03f..a6ebfdc2 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -4,8 +4,11 @@
 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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -13,24 +16,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]
 
@@ -38,43 +35,30 @@ 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 TestBackFlowTransformation(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 backflow transformation
-        self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse)
+        self.backflow_trans = BackFlowTransformation(self.mol, BackFlowKernelInverse)
 
         # define the grid points
         self.npts = 11
@@ -94,18 +78,17 @@ def test_backflow_derivative(self):
 
         # 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]
+        dq_grad = grad(q, self.pos, grad_outputs=torch.ones_like(self.pos))[0]
 
         # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
+        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))
+        assert torch.allclose(dq, dq_grad)
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -122,14 +105,14 @@ def test_backflow_second_derivative(self):
         d2q_auto = hess(q, self.pos)
 
         # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
+        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))
+        assert torch.allclose(d2q, d2q_auto)
 
 
 if __name__ == "__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 d7ac6573..996d6543 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
@@ -4,8 +4,11 @@
 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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -13,24 +16,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]
 
@@ -38,43 +35,32 @@ 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 TestOrbitalDependentBackFlowTransformation(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 backflow transformation
         self.backflow_trans = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # set the weights to random
         for ker in self.backflow_trans.backflow_kernel.orbital_dependent_kernel:
@@ -103,21 +89,23 @@ def test_backflow_derivative(self):
         for iq in range(nao):
             qao = q[:, iq, ...]
             dqao = grad(
-                qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True)[0]
+                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)
+                    (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis
+                )
         # checksum
-        assert(torch.allclose(dq.sum(), dq_grad.sum()))
+        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))
+        assert torch.allclose(dq, dq_grad)
 
     def test_backflow_second_derivative(self):
         """Test the derivative of the bf coordinate wrt the initial positions."""
@@ -140,18 +128,19 @@ def test_backflow_second_derivative(self):
                 d2q_auto = d2qao
             else:
                 d2q_auto = torch.cat(
-                    (d2q_auto, d2qao), axis=self.backflow_trans.backflow_kernel.stack_axis)
+                    (d2q_auto, d2qao),
+                    axis=self.backflow_trans.backflow_kernel.stack_axis,
+                )
 
         # checksum
-        assert(torch.allclose(d2q.sum(), d2q_auto.sum()))
+        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)
+        d2q_auto = d2q_auto.reshape(self.npts, nao, self.mol.nelec, 3)
 
-        assert(torch.allclose(d2q, d2q_auto))
+        assert torch.allclose(d2q, d2q_auto)
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index 3bfad9ed..a1466c84 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -6,21 +6,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]
 
@@ -28,96 +23,81 @@ 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 BaseTestAO:
-
     class BaseTestAOderivatives(unittest.TestCase):
-
         def setUp(self):
-
             def ao_callable(pos, derivative=0, sum_grad=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]
+            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()))
+            assert torch.allclose(dao.sum(), dao_grad.sum())
 
         def test_ao_grad_sum(self):
-
             ao = 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)))
+            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()))
+            assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
 
         def test_ao_hess_sum(self):
-
             ao = 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)))
+            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])
+            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)
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 f3322694..3c0efc9e 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -8,17 +8,16 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
index b4f06eb8..b3389f02 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_pyscf.py
@@ -8,23 +8,19 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 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')
+        at = "Li 0 0 0; H 0 0 1"
+        basis = "dzp"
+        self.mol = Molecule(atom=at, calculator="pyscf", basis=basis, unit="bohr")
 
         # define the aos
         self.ao = AtomicOrbitals(self.mol)
diff --git a/tests/wavefunction/orbitals/test_ao_values_adf.py b/tests/wavefunction/orbitals/test_ao_values_adf.py
index 7537109d..774159f7 100644
--- a/tests/wavefunction/orbitals/test_ao_values_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_adf.py
@@ -16,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
 
 
@@ -33,52 +33,46 @@ 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
@@ -94,17 +88,13 @@ def setUp(self):
         self.pos.requires_grad = True
 
     def test_ao(self):
-
         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)
 
@@ -119,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 8215619d..a4c6642e 100644
--- a/tests/wavefunction/orbitals/test_ao_values_pyscf.py
+++ b/tests/wavefunction/orbitals/test_ao_values_pyscf.py
@@ -13,18 +13,13 @@
 
 
 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.ao = AtomicOrbitals(self.mol)
@@ -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.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.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 0bffd269..50e6c8aa 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -4,9 +4,14 @@
 from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -14,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]
 
@@ -39,42 +38,31 @@ 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)
+            self.mol, BackFlowKernelInverse, orbital_dependent=False
+        )
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -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 20b856fd..eb609510 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -7,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]
 
@@ -32,69 +26,59 @@ 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):
@@ -104,14 +88,12 @@ def test_value(self):
     def test_grad(self):
         xyz, r = 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()
@@ -119,8 +101,7 @@ def test_jac(self):
         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()
@@ -128,8 +109,7 @@ def test_lap(self):
         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()
@@ -137,8 +117,7 @@ def test_mixed_der(self):
         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 72d86d0a..5e947026 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -11,29 +11,24 @@
 
 
 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.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, _ = self.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -43,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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
         dR = dR.detach().numpy()
@@ -70,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.ao._process_position(self.pos)
-        R, dR = self.ao.harmonics(
-            xyz, derivative=[0, 1], sum_grad=False)
+        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)
@@ -131,11 +119,9 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         xyz, _ = self.ao._process_position(self.pos)
-        R, _, d2R = self.ao.harmonics(
-            xyz, derivative=[0, 1, 2], sum_grad=False)
+        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)
 
@@ -143,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]
@@ -157,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)
@@ -172,13 +157,11 @@ def test_lap_sum(self):
         npts = 100
         self.pos = torch.rand(npts, self.mol.nelec * 3)
         xyz, r = self.ao._process_position(self.pos)
-        d2R_sum = self.ao.harmonics(
-            xyz, derivative=2, sum_hess=True)
+        d2R_sum = self.ao.harmonics(xyz, derivative=2, sum_hess=True)
 
-        d2R = self.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 331cdfe5..73841d09 100644
--- a/tests/wavefunction/orbitals/test_mo_values_adf.py
+++ b/tests/wavefunction/orbitals/test_mo_values_adf.py
@@ -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()
 
         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 fd2245d0..6e634ff7 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
@@ -4,9 +4,14 @@
 from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
-from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
+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
+
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 torch.manual_seed(101)
@@ -14,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]
 
@@ -39,43 +38,32 @@ 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
         backflow = BackFlowTransformation(
-            self.mol, BackFlowKernelInverse, orbital_dependent=True)
+            self.mol, BackFlowKernelInverse, orbital_dependent=True
+        )
 
         # define the wave function
         self.ao = AtomicOrbitalsBackFlow(self.mol, backflow)
@@ -97,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 eca5542d..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,16 +77,15 @@ 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):
@@ -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 fc563ed2..19802c20 100644
--- a/tests/wavefunction/orbitals/test_radial_gto.py
+++ b/tests/wavefunction/orbitals/test_radial_gto.py
@@ -9,33 +9,35 @@
 
 
 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.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.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, 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()
@@ -45,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.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, 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()
@@ -76,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.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, 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)
@@ -138,14 +139,16 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = z
 
         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)
+        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)
 
@@ -153,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]
@@ -170,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 d4b2fb83..614ad256 100644
--- a/tests/wavefunction/orbitals/test_radial_sto.py
+++ b/tests/wavefunction/orbitals/test_radial_sto.py
@@ -9,34 +9,32 @@
 from .second_derivative import second_derivative
 
 
-
 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.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.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, 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()
@@ -46,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.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, 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()
@@ -77,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.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, 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)
@@ -140,23 +137,25 @@ def test_laplacian(self, eps=1E-4):
         self.pos[:, 14] = torch.linspace(-4, 4, npts)
 
         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)
+        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]
@@ -169,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 0300faf3..bb58bebe 100644
--- a/tests/wavefunction/orbitals/test_spherical_harmonics.py
+++ b/tests/wavefunction/orbitals/test_spherical_harmonics.py
@@ -6,12 +6,11 @@
 
 
 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/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 8baf5130..dc18ba52 100644
--- a/tests/wavefunction/pooling/test_slater.py
+++ b/tests/wavefunction/pooling/test_slater.py
@@ -9,72 +9,73 @@
 
 
 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.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.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 5c7f874e..33abb837 100644
--- a/tests/wavefunction/pooling/test_trace_trick.py
+++ b/tests/wavefunction/pooling/test_trace_trick.py
@@ -30,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
 
@@ -64,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]
 
@@ -98,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]
 
@@ -134,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
@@ -150,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)
 
@@ -170,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]
 
@@ -207,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]
 
@@ -229,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):
@@ -247,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
@@ -272,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
@@ -288,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 992a0c2a..1ff3cbc6 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -5,11 +5,17 @@
 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.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.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
 
@@ -17,9 +23,7 @@
 
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,43 +31,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)
+            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,)
+            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.
-
-        self.wf_ref = SlaterJastrow(mol,
-                                    kinetic='jacobi',
-                                    include_all_mo=True,
-                                    configs='single_double(2,2)',
-                                    jastrow=jastrow,
-                                    backflow=None)
+            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):
@@ -71,43 +82,38 @@ 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)))
+        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__":
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index e70762d7..487d8b05 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -5,11 +5,17 @@
 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.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.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
 
@@ -17,9 +23,7 @@
 
 
 class TestCompareSlaterJastrowOrbitalDependentBackFlow(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,44 +31,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)
+            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)
+        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)
+            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)',
-                                    jastrow=jastrow,
-                                    backflow=None)
+        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):
@@ -72,43 +80,38 @@ 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)))
+        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__":
diff --git a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
index 2b29baa8..2420ebb9 100644
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -15,21 +15,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]
 
@@ -37,9 +32,7 @@ def hess(out, pos):
 
 
 class TestSlaterJastrowGraph(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -47,35 +40,33 @@ 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)
+            atom="Li 0 0 0; H 0 0 3.14",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         # jastrow
-        jastrow = JastrowFactor(mol,
-                                ee_model=MGCNPredictor,
-                                ee_model_kwargs={'n_layers': 3,
-                                                 'feats': 32,
-                                                 'cutoff': 5.0,
-                                                 'gap': 1.},
-                                en_model=MGCNPredictor,
-                                en_model_kwargs={'n_layers': 3,
-                                                 'feats': 32,
-                                                 'cutoff': 5.0,
-                                                 'gap': 1.0})
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow)
+        jastrow = JastrowFactor(
+            mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
+        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):
@@ -88,8 +79,10 @@ def test_antisymmetry(self):
 
         if self.wf.nelec < 4:
             print(
-                'Warning : antisymmetry cannot be tested with \
-                    only %d electrons' % self.wf.nelec)
+                "Warning : antisymmetry cannot be tested with \
+                    only %d electrons"
+                % self.wf.nelec
+            )
             return
 
         # test spin up
@@ -98,23 +91,21 @@ def test_antisymmetry(self):
         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)
+        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))
+        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
+        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)
+        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))
+        assert torch.allclose(wfvals_ref, -1 * wfvals_xdn)
 
     def test_grad_mo(self):
         """Gradients of the MOs."""
@@ -122,16 +113,14 @@ def test_grad_mo(self):
         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]
+        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)))
+        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."""
@@ -140,47 +129,43 @@ def test_hess_mo(self):
         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(), 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).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)))
+        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)
+        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)
+        assert torch.allclose(eauto.data, ejac.data, rtol=1e-4, atol=1e-4)
 
     def test_gradients_wf(self):
-
-        grads = self.wf.gradients_jacobi_no_backflow(
-            self.pos, sum_grad=False).squeeze()
+        grads = self.wf.gradients_jacobi_no_backflow(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))
+        assert torch.allclose(grads, grad_auto)
 
     def test_gradients_pdf(self):
-
         grads_pdf = self.wf.gradients_jacobi_no_backflow(self.pos, pdf=True)
         grads_auto = self.wf.gradients_autograd(self.pos, pdf=True)
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow.py b/tests/wavefunction/test_slatercombinedjastrow.py
index 4597fb45..59355b19 100644
--- a/tests/wavefunction/test_slatercombinedjastrow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow.py
@@ -7,19 +7,25 @@
 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
+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,
+)
 
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
 class TestSlaterCombinedJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -27,33 +33,35 @@ 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)
+            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.},
-                                                 'en': {'w': 1.},
-                                                 'een': {}})
+        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.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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 6d4c55f5..fbb9a6aa 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -7,13 +7,25 @@
 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.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
 
@@ -22,9 +34,7 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -32,40 +42,41 @@ 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.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.},
-                                                 'en': {'w': 1.},
-                                                 'een': {}})
+        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)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='jacobi',
-                                include_all_mo=True,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=backflow)
+        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
 
 
diff --git a/tests/wavefunction/test_slatercombinedjastrow_internal.py b/tests/wavefunction/test_slatercombinedjastrow_internal.py
index 861cc674..661a25b3 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_internal.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_internal.py
@@ -7,17 +7,21 @@
 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
+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)
 
@@ -25,27 +29,29 @@ 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)
+            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.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 = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
 
diff --git a/tests/wavefunction/test_slaterjastrow.py b/tests/wavefunction/test_slaterjastrow.py
index d1f2e600..d8a4b0ee 100644
--- a/tests/wavefunction/test_slaterjastrow.py
+++ b/tests/wavefunction/test_slaterjastrow.py
@@ -1,4 +1,3 @@
-
 import unittest
 import numpy as np
 import torch
@@ -9,7 +8,9 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
@@ -20,9 +21,7 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -30,28 +29,29 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=None)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 7f2ac909..3c07b012 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -9,7 +9,10 @@
 
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
+from qmctorch.wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 
 from qmctorch.utils import set_torch_double_precision
 
@@ -18,9 +21,7 @@
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -28,33 +29,33 @@ 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.015",
+            unit="bohr",
+            calculator="pyscf",
+            basis="sto-3g",
+            redo_scf=True,
+        )
 
         # define jastrow factor
-        jastrow = JastrowFactor(
-            mol, PadeJastrowKernel)
+        jastrow = JastrowFactor(mol, PadeJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='jacobi',
-                                include_all_mo=True,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=backflow)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_cas.py b/tests/wavefunction/test_slaterjastrow_cas.py
index 7a40c1b8..3a47cd59 100644
--- a/tests/wavefunction/test_slaterjastrow_cas.py
+++ b/tests/wavefunction/test_slaterjastrow_cas.py
@@ -7,7 +7,9 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
@@ -16,9 +18,7 @@
 
 
 class TestSlaterJastrowCAS(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -26,28 +26,29 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=True,
-                                configs='cas(2,2)',
-                                jastrow=jastrow)
+        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
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_ee_cusp.py b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
index 8f0ca6b7..6038c7a6 100644
--- a/tests/wavefunction/test_slaterjastrow_ee_cusp.py
+++ b/tests/wavefunction/test_slaterjastrow_ee_cusp.py
@@ -8,7 +8,9 @@
 
 from qmctorch.utils import set_torch_double_precision
 
-from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron
+from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 
@@ -16,9 +18,7 @@
 
 
 class TestSlaterJastrowElectronCusp(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -26,38 +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)
-
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel)
-
-        self.wf = SlaterJastrow(mol,
-                                jastrow=jastrow,
-                                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()
@@ -65,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 b8d8a40e..d3bdf158 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -8,11 +8,17 @@
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import BackFlowTransformation
-from qmctorch.wavefunction.orbitals.backflow.kernels.backflow_kernel_inverse import BackFlowKernelInverse
+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
 
@@ -21,9 +27,7 @@
 
 
 class TestSlaterJastrow(BaseTestCases.WaveFunctionBaseTest):
-
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -31,32 +35,32 @@ 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)
+            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)
+        jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(
-            mol, BackFlowKernelInverse)
+        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
-        self.wf = SlaterJastrow(mol,
-                                kinetic='auto',
-                                include_all_mo=False,
-                                configs='single_double(2,2)',
-                                jastrow=jastrow,
-                                backflow=backflow)
+        self.wf = SlaterJastrow(
+            mol,
+            kinetic="auto",
+            include_all_mo=False,
+            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 = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 9072b9c5..443f1419 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -1,5 +1,3 @@
-
-
 import numpy as np
 import torch
 import unittest
@@ -9,11 +7,17 @@
 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.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.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
 
@@ -21,10 +25,10 @@
 torch.set_default_tensor_type(torch.DoubleTensor)
 
 
-class TestSlaterJastrowOrbitalDependentBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):
-
+class TestSlaterJastrowOrbitalDependentBackFlow(
+    BaseTestCases.BackFlowWaveFunctionBaseTest
+):
     def setUp(self):
-
         torch.manual_seed(101)
         np.random.seed(101)
 
@@ -32,26 +36,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)
+            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)
+        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)
+            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:
@@ -61,8 +68,7 @@ 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
 
 

From 60859533ce046e7b650ae1c600c2ab3474a03060 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 13:15:08 +0100
Subject: [PATCH 110/286] black formatting

---
 qmctorch/sampler/metropolis.py                              | 4 ++--
 qmctorch/sampler/proposal_kernels.py                        | 2 +-
 qmctorch/sampler/walkers.py                                 | 2 +-
 qmctorch/scf/calculator/adf.py                              | 4 +++-
 qmctorch/scf/molecule.py                                    | 1 -
 qmctorch/solver/solver_mpi.py                               | 2 +-
 qmctorch/utils/interpolate.py                               | 5 +++--
 qmctorch/wavefunction/__init__.py                           | 2 --
 qmctorch/wavefunction/jastrows/elec_elec/__init__.py        | 3 ++-
 qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py      | 6 +-----
 qmctorch/wavefunction/orbitals/backflow/__init__.py         | 4 ++--
 qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py | 4 ++--
 12 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index d4ac3ea5..0bacd5af 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -260,14 +260,14 @@ def _move(self, num_elec: int) -> torch.Tensor:
                 (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)
-            return 
+            return
 
         elif self.movedict["proba"] == "normal":
             displacement = self.multiVariate.sample(
                 (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:
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index c0ddded4..7471056d 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -1,6 +1,6 @@
-
 import torch
 
+
 class DensityVarianceKernel(object):
     def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
         self.atomic_pos = atomic_pos.unsqueeze(0).unsqueeze(1)
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index f975e1f2..6ba4ffcd 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -5,7 +5,7 @@
 from .. import log
 
 
-class Walkers():
+class Walkers:
     def __init__(
         self,
         nwalkers: int = 100,
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 33569927..3a034e86 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -256,7 +256,9 @@ def read_array(kf, section, name):
 
 
 class CalculatorADF2019(CalculatorADF):
-    def __init__(self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile):
+    def __init__(
+        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+    ):
         CalculatorADF.__init__(
             self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
         )
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 4e6f1de5..a5532a71 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -15,7 +15,6 @@
     log.info("  MPI not found.")
 
 
-
 class Molecule:
     def __init__(
         self,
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 7882b0da..4aba215d 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -219,7 +219,7 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
         )
 
         if batchsize is not None:
-            log.info('  Batchsize not supported for MPI solver')
+            log.info("  Batchsize not supported for MPI solver")
 
         # check if we have to compute and store the grads
         grad_mode = torch.no_grad()
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index 3670800a..c0b0c2ab 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -17,13 +17,14 @@ def __init__(self, wf):
     def __call__(self, pos, method="irreg", orb="occupied", **kwargs):
         if method == "irreg":
             n = kwargs["n"] if "n" in kwargs else 6
-            out =  self.interpolate_mo_irreg_grid(pos, n=n, orb=orb)
+            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.0
-            out =  self.interpolate_mo_reg_grid(pos, res, blength, orb)
+            out = self.interpolate_mo_reg_grid(pos, res, blength, orb)
         return out
+
     def get_mo_max_index(self, orb):
         """Get the index of the highest MO to inlcude in the interpoaltion
 
diff --git a/qmctorch/wavefunction/__init__.py b/qmctorch/wavefunction/__init__.py
index 0d1028ef..b234afcc 100644
--- a/qmctorch/wavefunction/__init__.py
+++ b/qmctorch/wavefunction/__init__.py
@@ -3,5 +3,3 @@
 from .slater_orbital_dependent_jastrow import SlaterOrbitalDependentJastrow
 
 __all__ = ["WaveFunction", "SlaterJastrow", "SlaterOrbitalDependentJastrow"]
-
-
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
index 4ee206fd..43261d1d 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/__init__.py
@@ -9,4 +9,5 @@
     "JastrowFactor",
     "PadeJastrowKernel",
     "FullyConnectedJastrowKernel",
-    "PadeJastrowPolynomialKernel"]
\ No newline at end of file
+    "PadeJastrowPolynomialKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
index b54078b9..386aea4b 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/__init__.py
@@ -2,8 +2,4 @@
 from .kernels.pade_jastrow_kernel import PadeJastrowKernel
 from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 
-__all__ = [
-    "JastrowFactor",
-    "PadeJastrowKernel",
-    "FullyConnectedJastrowKernel"
-]
\ No newline at end of file
+__all__ = ["JastrowFactor", "PadeJastrowKernel", "FullyConnectedJastrowKernel"]
diff --git a/qmctorch/wavefunction/orbitals/backflow/__init__.py b/qmctorch/wavefunction/orbitals/backflow/__init__.py
index bd4a57b1..372fa16e 100644
--- a/qmctorch/wavefunction/orbitals/backflow/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/__init__.py
@@ -13,5 +13,5 @@
     "BackFlowKernelFullyConnected",
     "BackFlowKernelInverse",
     "BackFlowKernelPowerSum",
-    "BackFlowKernelSquare"
-]
\ No newline at end of file
+    "BackFlowKernelSquare",
+]
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index e4b9575c..7f51395b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -11,5 +11,5 @@
     "BackFlowKernelFullyConnected",
     "BackFlowKernelInverse",
     "BackFlowKernelPowerSum",
-    "BackFlowKernelSquare"
-]
\ No newline at end of file
+    "BackFlowKernelSquare",
+]

From 4c2a3542b41508a0134b6a1a4085215ba06e63f6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 13:20:27 +0100
Subject: [PATCH 111/286] fix mcgn test

---
 tests/wavefunction/test_slater_mgcn_graph_jastrow.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
index 2420ebb9..11ca4c4c 100644
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -156,7 +156,7 @@ def test_kinetic_energy(self):
         assert torch.allclose(eauto.data, ejac.data, rtol=1e-4, atol=1e-4)
 
     def test_gradients_wf(self):
-        grads = self.wf.gradients_jacobi_no_backflow(self.pos, sum_grad=False).squeeze()
+        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())
@@ -166,7 +166,7 @@ def test_gradients_wf(self):
         assert torch.allclose(grads, grad_auto)
 
     def test_gradients_pdf(self):
-        grads_pdf = self.wf.gradients_jacobi_no_backflow(self.pos, pdf=True)
+        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())

From a32e7e21de06dc7427608a0bc77ee3b9055a9068 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 13:27:29 +0100
Subject: [PATCH 112/286] fix ao callable args

---
 tests/wavefunction/orbitals/base_test_ao.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index a1466c84..43526eb9 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -58,7 +58,7 @@ def hess_mixed_terms(out, pos):
 class BaseTestAO:
     class BaseTestAOderivatives(unittest.TestCase):
         def setUp(self):
-            def ao_callable(pos, derivative=0, sum_grad=False):
+            def ao_callable(pos, derivative=0, sum_grad=False, sum_hess=False):
                 """Callable for the AO"""
                 return None
 

From d5bc69e607e57bbccdcbdb0d20879255c847b15e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 14:02:46 +0100
Subject: [PATCH 113/286] fix metropolis

---
 qmctorch/sampler/metropolis.py                                | 1 -
 tests/sampler/test_hamiltonian.py                             | 2 +-
 .../jastrows/elec_elec/base_elec_elec_jastrow_test.py         | 2 +-
 tests/wavefunction/jastrows/test_combined_terms.py            | 2 +-
 tests/wavefunction/orbitals/base_test_ao.py                   | 4 ++--
 tests/wavefunction/orbitals/test_cartesian_harmonics.py       | 2 +-
 tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py   | 2 +-
 7 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 0bacd5af..49bfcf97 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -260,7 +260,6 @@ def _move(self, num_elec: int) -> torch.Tensor:
                 (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)
-            return
 
         elif self.movedict["proba"] == "normal":
             displacement = self.multiVariate.sample(
diff --git a/tests/sampler/test_hamiltonian.py b/tests/sampler/test_hamiltonian.py
index 8ffb7c8d..40470744 100644
--- a/tests/sampler/test_hamiltonian.py
+++ b/tests/sampler/test_hamiltonian.py
@@ -16,7 +16,7 @@ def test_hmc(self):
             init=self.mol.domain("normal"),
         )
 
-        pos = sampler(self.wf.pdf)
+        _ = sampler(self.wf.pdf)
 
 
 if __name__ == "__main__":
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
index cdc90d2a..3e325669 100644
--- a/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
+++ b/tests/wavefunction/jastrows/elec_elec/base_elec_elec_jastrow_test.py
@@ -38,7 +38,7 @@ def jastrow_callable(pos, derivative=0, sum_grad=False):
 
         def test_jastrow(self):
             """simply checks that the values are not crashing."""
-            val = self.jastrow(self.pos)
+            _ = self.jastrow(self.pos)
 
         def test_permutation(self):
             jval = self.jastrow(self.pos)
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index 56b6da71..8f15ecdf 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -68,7 +68,7 @@ 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)
diff --git a/tests/wavefunction/orbitals/base_test_ao.py b/tests/wavefunction/orbitals/base_test_ao.py
index 43526eb9..c87e16fd 100644
--- a/tests/wavefunction/orbitals/base_test_ao.py
+++ b/tests/wavefunction/orbitals/base_test_ao.py
@@ -74,7 +74,7 @@ def test_ao_deriv(self):
             assert torch.allclose(dao.sum(), dao_grad.sum())
 
         def test_ao_grad_sum(self):
-            ao = self.ao(self.pos)
+            _ = 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)
 
@@ -87,7 +87,7 @@ def test_ao_hess(self):
             assert torch.allclose(d2ao.sum(), d2ao_grad.sum())
 
         def test_ao_hess_sum(self):
-            ao = self.ao(self.pos)
+            _ = 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))
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics.py b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
index eb609510..cbe3fc3d 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -86,7 +86,7 @@ def test_value(self):
         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)
 
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
index 5e947026..500be4b6 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -52,7 +52,7 @@ def test_first_derivative_y(self):
         self.pos[:, 1] = torch.linspace(-4, 4, npts)
         self.dy = self.pos[1, 1] - self.pos[0, 1]
 
-        xyz, r = self.ao._process_position(self.pos)
+        xyz, _ = self.ao._process_position(self.pos)
         R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()

From eea00912218ba96d00d7e1c69bcd5ea8e1505dfd Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 14:05:42 +0100
Subject: [PATCH 114/286] remove backlfow from generic jastrow test

---
 tests/wavefunction/test_slaterjastrow_generic.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index d3bdf158..0de7620d 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -46,7 +46,7 @@ def setUp(self):
         jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
 
         # define backflow trans
-        backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
+        # backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
 
         self.wf = SlaterJastrow(
             mol,
@@ -54,7 +54,7 @@ def setUp(self):
             include_all_mo=False,
             configs="single_double(2,2)",
             jastrow=jastrow,
-            backflow=backflow,
+            backflow=None,
         )
 
         self.random_fc_weight = torch.rand(self.wf.fc.weight.shape)

From 51798b6f4f536d48d5dfa8ebea31e1a54724d3a4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 14:24:28 +0100
Subject: [PATCH 115/286] coday fix

---
 qmctorch/wavefunction/slater_jastrow.py                |  2 +-
 .../wavefunction/orbitals/test_cartesian_harmonics.py  |  6 +++---
 .../orbitals/test_cartesian_harmonics_adf.py           |  4 ++--
 tests/wavefunction/test_slaterjastrow_generic.py       | 10 +---------
 4 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 6f13b0fc..a3d0ec5c 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -535,7 +535,7 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
 
         return -0.5 * out.unsqueeze(-1)
 
-    def gradients_jacobi_backflow(self, x, sum_grad=True):
+    def gradients_jacobi_backflow(self, x, sum_grad=True, pdf=False):
         """Computes the gradients of the wf using Jacobi's Formula
 
         Args:
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics.py b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
index cbe3fc3d..32ae5214 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics.py
@@ -96,7 +96,7 @@ def test_grad(self):
         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]
@@ -104,7 +104,7 @@ def test_jac(self):
         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)
@@ -112,7 +112,7 @@ def test_lap(self):
         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)
diff --git a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
index 500be4b6..3a725d4b 100644
--- a/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
+++ b/tests/wavefunction/orbitals/test_cartesian_harmonics_adf.py
@@ -77,7 +77,7 @@ def test_first_derivative_z(self):
         self.pos[:, 2] = torch.linspace(-4, 4, npts)
         self.dz = self.pos[1, 2] - self.pos[0, 2]
 
-        xyz, r = self.ao._process_position(self.pos)
+        xyz, _ = self.ao._process_position(self.pos)
         R, dR = self.ao.harmonics(xyz, derivative=[0, 1], sum_grad=False)
 
         R = R.detach().numpy()
@@ -156,7 +156,7 @@ 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.ao._process_position(self.pos)
+        xyz, _ = self.ao._process_position(self.pos)
         d2R_sum = self.ao.harmonics(xyz, derivative=2, sum_hess=True)
 
         d2R = self.ao.harmonics(xyz, derivative=2, sum_hess=False)
diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 0de7620d..72fe597e 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -13,12 +13,7 @@
 )
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
-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
 
@@ -45,9 +40,6 @@ def setUp(self):
         # define jastrow factor
         jastrow = JastrowFactorElectronElectron(mol, FullyConnectedJastrowKernel)
 
-        # define backflow trans
-        # backflow = BackFlowTransformation(mol, BackFlowKernelInverse)
-
         self.wf = SlaterJastrow(
             mol,
             kinetic="auto",

From 2905be866acdddaafbab3014560a75981bd5950d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 14:35:03 +0100
Subject: [PATCH 116/286] codacy fix

---
 .prospector.yml                                             | 1 +
 qmctorch/solver/solver.py                                   | 1 +
 qmctorch/utils/plot_data.py                                 | 2 +-
 .../wavefunction/jastrows/elec_nuclei/kernels/__init__.py   | 6 ++++++
 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py           | 2 +-
 5 files changed, 10 insertions(+), 2 deletions(-)

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/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index fd68eaf6..1fa74c11 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -316,6 +316,7 @@ def run_epochs(self, nepoch):
 
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
+        min_loss = torch.inf
 
         # loop over the epoch
         for n in range(nepoch):
diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 17631d7b..5aab9334 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -245,7 +245,7 @@ def plot_block(eloc):
         eloc (np.array): values of the local energy
     """
 
-    nstep, nwalkers = eloc.shape
+    nstep, _ = eloc.shape
     max_block_size = nstep // 2
 
     evar = []
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
index 177e5efb..215167a3 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"
+]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
index 871927d6..a37633af 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -256,7 +256,7 @@ class MGCNGNN(nn.Module):
         Difference between two adjacent centers in RBF expansion. Default to 0.1.
     """
 
-    def __init__(
+    def __init__( # pylint: disable=to-many-arguments
         self,
         feats=128,
         n_layers=3,

From 69dd17e427f323e7743ce0c6f745bc4b09659e72 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 14:58:54 +0100
Subject: [PATCH 117/286] codacy fix

---
 qmctorch/sampler/generalized_metropolis.py    |  2 +-
 qmctorch/sampler/metropolis.py                |  7 ++--
 qmctorch/sampler/walkers.py                   |  2 +-
 qmctorch/scf/calculator/adf.py                |  2 +-
 qmctorch/scf/molecule.py                      |  4 +--
 qmctorch/solver/solver.py                     |  8 ++---
 qmctorch/solver/solver_base.py                |  4 +--
 qmctorch/solver/solver_mpi.py                 |  4 +--
 .../wavefunction/jastrows/combine_jastrow.py  | 35 ++++++++++---------
 .../jastrows/distance/__init__.py             |  5 +++
 .../distance/electron_nuclei_distance.py      |  2 +-
 .../jastrows/elec_elec/kernels/__init__.py    |  6 ++++
 .../jastrows/elec_elec_nuclei/__init__.py     |  6 ++++
 .../kernels/boys_handy_jastrow_kernel.py      |  2 +-
 .../wavefunction/jastrows/graph/__init__.py   |  5 +++
 15 files changed, 59 insertions(+), 35 deletions(-)

diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index dbf9deef..20beb60d 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -9,7 +9,7 @@
 
 
 class GeneralizedMetropolis(SamplerBase):
-    def __init__(
+    def __init__( #pylint: disable=dangerous-default-value
         self,
         nwalkers=100,
         nstep=1000,
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 49bfcf97..847e2179 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,7 +8,7 @@
 
 
 class Metropolis(SamplerBase):
-    def __init__(
+    def __init__( #pylint: disable=dangerous-default-value
         self,
         nwalkers: int = 100,
         nstep: int = 1000,
@@ -282,9 +282,10 @@ def _accept(self, proba: torch.Tensor) -> torch.Tensor:
             proba[proba > 0] = 0.0
             tau = torch.log(torch.rand_like(proba))
             index = (proba - tau >= 0).reshape(-1)
-            return index.type(torch.bool)
+            out = 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)
+            out = index.type(torch.bool)
+        return out
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index 6ba4ffcd..f200904b 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -6,7 +6,7 @@
 
 
 class Walkers:
-    def __init__(
+    def __init__( #pylint: disable=too-many-arguments
         self,
         nwalkers: int = 100,
         nelec: int = 1,
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 3a034e86..00a90cf9 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -15,7 +15,7 @@
 
 
 class CalculatorADF(CalculatorBase):
-    def __init__(
+    def __init__( #pylint: disable=too-many-arguments
         self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
     ):
         CalculatorBase.__init__(
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index a5532a71..695a1b22 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -16,8 +16,8 @@
 
 
 class Molecule:
-    def __init__(
-        self,
+    def __init__( #pylint: disable=too-many-arguments
+        self, 
         atom=None,
         calculator="adf",
         scf="hf",
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 1fa74c11..e31b9cb2 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -9,7 +9,7 @@
 
 
 class Solver(SolverBase):
-    def __init__(
+    def __init__( #pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Basic QMC solver
@@ -36,7 +36,7 @@ def __init__(
             resampling={"mode": "update", "resample_every": 1, "nstep_update": 25},
         )
 
-    def configure(
+    def configure( #pylint: disable=too-many-arguments
         self,
         track=None,
         freeze=None,
@@ -159,7 +159,7 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
-    def geo_opt(
+    def geo_opt( #pylint: disable=too-many-arguments
         self,
         nepoch,
         geo_lr=1e-2,
@@ -316,7 +316,7 @@ def run_epochs(self, nepoch):
 
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
-        min_loss = torch.inf
+        min_loss = 0 # this is set at n=0
 
         # loop over the epoch
         for n in range(nepoch):
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 29a54092..c6e8f053 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -9,7 +9,7 @@
 
 
 class SolverBase:
-    def __init__(
+    def __init__( #pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Base Class for QMC solver
@@ -60,7 +60,7 @@ def __init__(
 
         self.log_data()
 
-    def configure_resampling(
+    def configure_resampling( #pylint: disable=too-many-arguments
         self,
         mode="update",
         resample_every=1,
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 4aba215d..b43d2b26 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -19,7 +19,7 @@ def logd(rank, *args):
 
 
 class SolverMPI(Solver):
-    def __init__(
+    def __init__( #pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Distributed QMC solver
@@ -42,7 +42,7 @@ def __init__(
 
         self.sampler.walkers.nwalkers //= hvd.size()
 
-    def run(
+    def run( #pylint: disable=too-many-arguments
         self,
         nepoch,
         batchsize=None,
diff --git a/qmctorch/wavefunction/jastrows/combine_jastrow.py b/qmctorch/wavefunction/jastrows/combine_jastrow.py
index 972266be..79486229 100644
--- a/qmctorch/wavefunction/jastrows/combine_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/combine_jastrow.py
@@ -138,23 +138,24 @@ def get_second_derivative_combined_values(jast_vals, djast_vals, d2jast_vals):
         """
         if len(d2jast_vals) == 1:
             return d2jast_vals[0]
-        else:
-            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]
+        # 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)
+                out = out + (2.0 * reduce(lambda x, y: x * y, tmp)).sum(1)
 
-            return out
+        return out
diff --git a/qmctorch/wavefunction/jastrows/distance/__init__.py b/qmctorch/wavefunction/jastrows/distance/__init__.py
index a34c958e..ba551284 100644
--- a/qmctorch/wavefunction/jastrows/distance/__init__.py
+++ b/qmctorch/wavefunction/jastrows/distance/__init__.py
@@ -1,2 +1,7 @@
 from .electron_electron_distance import ElectronElectronDistance
 from .electron_nuclei_distance import ElectronNucleiDistance
+
+__all__ = [
+    "ElectronElectronDistance",
+    "ElectronNucleiDistance"
+]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index bba5e66b..a0ca3e2e 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -59,7 +59,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:
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
index f9413743..82cf01cc 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
@@ -2,3 +2,9 @@
 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"
+]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index 8c4b6053..9ed1cea1 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -3,3 +3,9 @@
 )
 from .kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+
+__all__ = [
+    "JastrowFactor",
+    "BoysHandyJastrowKernel",
+    "FullyConnectedJastrowKernel"
+]
\ No newline at end of file
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 96111e7d..030a9233 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
@@ -6,7 +6,7 @@
 
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, nterm=5):
+    def __init__(self, nup, ndown, atomic_pos, cuda, nterm=5): #pylint: disable=too-many-arguments
         """Defines a Boys Handy jastrow factors.
 
         J.W. Moskowitz et. al
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index 600125c6..e668bb00 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,2 +1,7 @@
 from .jastrow_graph import JastrowFactorGraph as JastrowFactor
 from .mgcn.mgcn_predictor import MGCNPredictor
+
+__all__ = [
+    "JastrowFactor",
+    "MGCNPredictor"
+]
\ No newline at end of file

From bfa889421d8847cc254d8ef450ee7abff404fc76 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 15:09:42 +0100
Subject: [PATCH 118/286] exception in hdf5,py

---
 qmctorch/utils/hdf5_utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 4ce2dc54..513ac231 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -68,7 +68,8 @@ def load_group(grp, parent_obj, grp_name):
         if not hasattr(parent_obj, grp_name):
             parent_obj.__setattr__(grp_name, SimpleNamespace())
         load_object(grp, parent_obj.__getattribute__(grp_name), grp_name)
-    except:
+    except Exception as expt_message:
+        print(expt_message)
         print_load_error(grp_name)
 
 

From 803918581ceb2b00103db4e5289a961ea02e68bf Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 15:20:17 +0100
Subject: [PATCH 119/286] black src

---
 qmctorch/sampler/generalized_metropolis.py         |  2 +-
 qmctorch/sampler/metropolis.py                     |  2 +-
 qmctorch/sampler/walkers.py                        |  2 +-
 qmctorch/scf/calculator/adf.py                     |  2 +-
 qmctorch/scf/molecule.py                           |  4 ++--
 qmctorch/solver/solver.py                          |  8 ++++----
 qmctorch/solver/solver_base.py                     |  4 ++--
 qmctorch/solver/solver_mpi.py                      |  4 ++--
 qmctorch/utils/__init__.py                         | 14 +++++---------
 .../wavefunction/jastrows/distance/__init__.py     |  5 +----
 .../jastrows/distance/electron_nuclei_distance.py  |  2 +-
 .../jastrows/elec_elec/kernels/__init__.py         |  5 +++--
 .../jastrows/elec_elec_nuclei/__init__.py          |  6 +-----
 .../jastrows/elec_elec_nuclei/kernels/__init__.py  |  6 ++++++
 .../kernels/boys_handy_jastrow_kernel.py           |  4 +++-
 .../jastrows/elec_nuclei/kernels/__init__.py       |  4 ++--
 qmctorch/wavefunction/jastrows/graph/__init__.py   |  5 +----
 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py  |  2 +-
 18 files changed, 38 insertions(+), 43 deletions(-)

diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 20beb60d..d83aabbc 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -9,7 +9,7 @@
 
 
 class GeneralizedMetropolis(SamplerBase):
-    def __init__( #pylint: disable=dangerous-default-value
+    def __init__(  # pylint: disable=dangerous-default-value
         self,
         nwalkers=100,
         nstep=1000,
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index 847e2179..be30cbdb 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -8,7 +8,7 @@
 
 
 class Metropolis(SamplerBase):
-    def __init__( #pylint: disable=dangerous-default-value
+    def __init__(  # pylint: disable=dangerous-default-value
         self,
         nwalkers: int = 100,
         nstep: int = 1000,
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index f200904b..a85b111d 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -6,7 +6,7 @@
 
 
 class Walkers:
-    def __init__( #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         nwalkers: int = 100,
         nelec: int = 1,
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 00a90cf9..0d9e3f31 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -15,7 +15,7 @@
 
 
 class CalculatorADF(CalculatorBase):
-    def __init__( #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
         self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
     ):
         CalculatorBase.__init__(
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 695a1b22..85a027fb 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -16,8 +16,8 @@
 
 
 class Molecule:
-    def __init__( #pylint: disable=too-many-arguments
-        self, 
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
         atom=None,
         calculator="adf",
         scf="hf",
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index e31b9cb2..3cda3f07 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -9,7 +9,7 @@
 
 
 class Solver(SolverBase):
-    def __init__( #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Basic QMC solver
@@ -36,7 +36,7 @@ def __init__( #pylint: disable=too-many-arguments
             resampling={"mode": "update", "resample_every": 1, "nstep_update": 25},
         )
 
-    def configure( #pylint: disable=too-many-arguments
+    def configure(  # pylint: disable=too-many-arguments
         self,
         track=None,
         freeze=None,
@@ -159,7 +159,7 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
-    def geo_opt( #pylint: disable=too-many-arguments
+    def geo_opt(  # pylint: disable=too-many-arguments
         self,
         nepoch,
         geo_lr=1e-2,
@@ -316,7 +316,7 @@ def run_epochs(self, nepoch):
 
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
-        min_loss = 0 # this is set at n=0
+        min_loss = 0  # this is set at n=0
 
         # loop over the epoch
         for n in range(nepoch):
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index c6e8f053..eaec12b4 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -9,7 +9,7 @@
 
 
 class SolverBase:
-    def __init__( #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Base Class for QMC solver
@@ -60,7 +60,7 @@ def __init__( #pylint: disable=too-many-arguments
 
         self.log_data()
 
-    def configure_resampling( #pylint: disable=too-many-arguments
+    def configure_resampling(  # pylint: disable=too-many-arguments
         self,
         mode="update",
         resample_every=1,
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index b43d2b26..54e6a118 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -19,7 +19,7 @@ def logd(rank, *args):
 
 
 class SolverMPI(Solver):
-    def __init__( #pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments
         self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
     ):
         """Distributed QMC solver
@@ -42,7 +42,7 @@ def __init__( #pylint: disable=too-many-arguments
 
         self.sampler.walkers.nwalkers //= hvd.size()
 
-    def run( #pylint: disable=too-many-arguments
+    def run(  # pylint: disable=too-many-arguments
         self,
         nepoch,
         batchsize=None,
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index 10f8e555..dbfbfd64 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -10,17 +10,13 @@
 )
 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,
     DataLoader,
@@ -33,10 +29,6 @@
     gradients,
 )
 
-# __all__ = ['plot_energy', 'plot_data', 'plot_block',
-#            'plot_walkers_traj',
-#            'plot_correlation_time',
-#            'plot_autocorrelation',
 __all__ = [
     "set_torch_double_precision",
     "set_torch_single_precision",
@@ -44,6 +36,7 @@
     "Loss",
     "OrthoReg",
     "DataLoader",
+    "add_group_attr",
     "dump_to_hdf5",
     "load_from_hdf5",
     "bytes2str",
@@ -56,4 +49,7 @@
     "bproj",
     "diagonal_hessian",
     "gradients",
+    "blocking",
+    "correlation_coefficient",
+    "integrated_autocorrelation_time",
 ]
diff --git a/qmctorch/wavefunction/jastrows/distance/__init__.py b/qmctorch/wavefunction/jastrows/distance/__init__.py
index ba551284..27961cb8 100644
--- a/qmctorch/wavefunction/jastrows/distance/__init__.py
+++ b/qmctorch/wavefunction/jastrows/distance/__init__.py
@@ -1,7 +1,4 @@
 from .electron_electron_distance import ElectronElectronDistance
 from .electron_nuclei_distance import ElectronNucleiDistance
 
-__all__ = [
-    "ElectronElectronDistance",
-    "ElectronNucleiDistance"
-]
\ No newline at end of file
+__all__ = ["ElectronElectronDistance", "ElectronNucleiDistance"]
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index a0ca3e2e..a4a74957 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -59,7 +59,7 @@ def forward(self, input, derivative=0):
         dist = self._get_distance_quadratic(input_, self.atoms)
         dist = torch.sqrt(dist)
 
-        if derivative == 0: #pylint: disable=no-else-return
+        if derivative == 0:  # pylint: disable=no-else-return
             if self.scale:
                 return get_scaled_distance(self.kappa, dist)
             else:
diff --git a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
index 82cf01cc..189d22f2 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/__init__.py
@@ -2,9 +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"
-]
\ No newline at end of file
+    "PadeJastrowPolynomialKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
index 9ed1cea1..b3bf4d84 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/__init__.py
@@ -4,8 +4,4 @@
 from .kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 from .kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 
-__all__ = [
-    "JastrowFactor",
-    "BoysHandyJastrowKernel",
-    "FullyConnectedJastrowKernel"
-]
\ No newline at end of file
+__all__ = ["JastrowFactor", "BoysHandyJastrowKernel", "FullyConnectedJastrowKernel"]
diff --git a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
index 7810c835..fd172437 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec_nuclei/kernels/__init__.py
@@ -3,3 +3,9 @@
     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 030a9233..eae30937 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
@@ -6,7 +6,9 @@
 
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, nterm=5): #pylint: disable=too-many-arguments
+    def __init__(
+        self, nup, ndown, atomic_pos, cuda, nterm=5
+    ):  # pylint: disable=too-many-arguments
         """Defines a Boys Handy jastrow factors.
 
         J.W. Moskowitz et. al
diff --git a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
index 215167a3..6a042357 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/__init__.py
@@ -5,5 +5,5 @@
 __all__ = [
     "FullyConnectedJastrowKernel",
     "JastrowKernelElectronNucleiBase",
-    "PadeJastrowKernel"
-]
\ No newline at end of file
+    "PadeJastrowKernel",
+]
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index e668bb00..af55bd1c 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,7 +1,4 @@
 from .jastrow_graph import JastrowFactorGraph as JastrowFactor
 from .mgcn.mgcn_predictor import MGCNPredictor
 
-__all__ = [
-    "JastrowFactor",
-    "MGCNPredictor"
-]
\ No newline at end of file
+__all__ = ["JastrowFactor", "MGCNPredictor"]
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
index a37633af..4b69b18e 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -256,7 +256,7 @@ class MGCNGNN(nn.Module):
         Difference between two adjacent centers in RBF expansion. Default to 0.1.
     """
 
-    def __init__( # pylint: disable=to-many-arguments
+    def __init__(  # pylint: disable=to-many-arguments
         self,
         feats=128,
         n_layers=3,

From a799420d5d863eed9645c1296edc1246a3bb40e0 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 15:20:41 +0100
Subject: [PATCH 120/286] black test

---
 tests/wavefunction/test_slaterjastrow_generic.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/wavefunction/test_slaterjastrow_generic.py b/tests/wavefunction/test_slaterjastrow_generic.py
index 72fe597e..71ea923c 100644
--- a/tests/wavefunction/test_slaterjastrow_generic.py
+++ b/tests/wavefunction/test_slaterjastrow_generic.py
@@ -14,7 +14,6 @@
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 
 
-
 from qmctorch.utils import set_torch_double_precision
 
 

From 4ac815b1f6742496a62067a9203fbde089ddb2d8 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Nov 2023 16:01:35 +0100
Subject: [PATCH 121/286] black badge + example fix

---
 README.md                          | 1 +
 docs/example/autocorrelation/h2.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 76f14109..f6b5a2a3 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ Pytorch Implementation of Real Space Quantum Monte Carlo Simulations of Molecula
 [![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/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index 6c7ca9c9..6d0e17dd 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -4,7 +4,7 @@
 from qmctorch.sampler import Metropolis
 from qmctorch.scf import Molecule
 from qmctorch.solver import Solver
-from qmctorch.utils import plot_correlation_coefficient, plot_integrated_autocorrelation_time
+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)

From 7c31752923f3da4695c7b0afe2f2e971dddd831c Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 11:18:47 +0100
Subject: [PATCH 122/286] fix jastrow and backflow tutorials

---
 docs/notebooks/create_backflow.ipynb | 22 +++++++++++++-------
 docs/notebooks/create_jastrow.ipynb  | 30 ++++++++++++++++++++--------
 2 files changed, 37 insertions(+), 15 deletions(-)

diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index cd993268..4f5077e7 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -38,8 +38,10 @@
    "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)"
    ]
   },
@@ -59,7 +61,7 @@
    "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",
@@ -76,8 +78,16 @@
    "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": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "backflow = BackFlowTransformation(mol, MyBackflowKernel, backflow_kernel_kwargs={'size': 8})"
    ]
   },
   {
@@ -103,9 +113,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrowBackFlow(mol, \n",
-    "                   backflow_kernel=MyBackflow,\n",
-    "                   backflow_kernel_kwargs={'size' : 64})"
+    "wf = SlaterJastrow(mol, backflow=backflow)"
    ]
   },
   {
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index 20216768..7f789257 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -39,6 +39,7 @@
    "source": [
     "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\n",
     "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
    ]
@@ -59,7 +60,7 @@
    "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 +85,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": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This jastrow factor can then be passed as an argument of the `SlaterJastrow` wavefunction."
    ]
   },
   {
@@ -130,7 +144,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, jastrow_kernel=MyJastrow, jastrow_kernel_kwargs={'size' : 64})"
+    "wf = SlaterJastrow(mol, jastrow=jastrow)"
    ]
   },
   {

From 271cd331bd56bcaaf875a54106b0efc69e5126e6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 11:30:02 +0100
Subject: [PATCH 123/286] add combine jastrow example

---
 docs/index.rst                         |   1 +
 docs/notebooks/combining_jastrow.ipynb | 173 +++++++++++++++++++++++++
 docs/notebooks/create_backflow.ipynb   |   8 ++
 docs/notebooks/create_jastrow.ipynb    |   2 +-
 4 files changed, 183 insertions(+), 1 deletion(-)
 create mode 100644 docs/notebooks/combining_jastrow.ipynb

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/combining_jastrow.ipynb b/docs/notebooks/combining_jastrow.ipynb
new file mode 100644
index 00000000..7bb17f5d
--- /dev/null
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -0,0 +1,173 @@
+{
+ "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": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_sto-3g.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qmctorch.scf import Molecule\n",
+    "from qmctorch.wavefunction import SlaterJastrow\n",
+    "\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": null,
+   "metadata": {},
+   "outputs": [],
+   "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": null,
+   "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": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : MyJastrow\n",
+      "INFO:QMCTorch|  Highest MO included : 2\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 145\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
+   "source": [
+    "wf = SlaterJastrow(mol, jastrow=[jastrow_ee, jastrow_en])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmctorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index 4f5077e7..103d270f 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -90,6 +90,14 @@
     "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,
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index 7f789257..9b286a5b 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -98,7 +98,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel)"
+    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel, kernel_kwargs={'size': 64})"
    ]
   },
   {

From 5a06f7ac94f28f1ff8b0bbc63f07dd5f52a19efa Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 11:40:46 +0100
Subject: [PATCH 124/286] add test for orbital dependent jastrow

---
 .../test_slater_orbital_dependent_jastrow.py  | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 tests/wavefunction/test_slater_orbital_dependent_jastrow.py

diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
new file mode 100644
index 00000000..1392c61a
--- /dev/null
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -0,0 +1,59 @@
+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.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
+
+
+torch.set_default_tensor_type(torch.DoubleTensor)
+
+
+class TestSlaterJastrow(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,
+        )
+
+        # define jastrow factor
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel, orbital_dependent_kernel=True)
+
+        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.requires_grad = True
+
+
+if __name__ == "__main__":
+    unittest.main()

From b92f19fc2611772b7b022eaf4a03ab747417cd3c Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 12:01:08 +0100
Subject: [PATCH 125/286] default value for numorb for orbital dependent
 backflow

---
 .../jastrows/elec_elec/jastrow_factor_electron_electron.py  | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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 d88d7f1a..e63e5e99 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -29,7 +29,7 @@ def __init__(
             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.
         """
 
@@ -49,6 +49,10 @@ def __init__(
 
         # 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.nmo
+            # create the orbital dependent jastrow
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
                 mol.nup,
                 mol.ndown,

From 7bb2a3aff901dbe8036e86b58b77f49c131611f2 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 14:08:56 +0100
Subject: [PATCH 126/286] nmo through calc

---
 .../jastrows/elec_elec/jastrow_factor_electron_electron.py      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 e63e5e99..ea097a61 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -51,7 +51,7 @@ def __init__(
         if orbital_dependent_kernel:
             # default to all orbitals if number_of_orbitals is None
             if number_of_orbitals is None:
-                number_of_orbitals = mol.nmo
+                number_of_orbitals = mol.calculator.basis.nmo
             # create the orbital dependent jastrow
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
                 mol.nup,

From f556604cd94f10344410a9ad832a0c2e39e2732b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 14:27:08 +0100
Subject: [PATCH 127/286] fix nmo via basis

---
 docs/example/scf/scf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index a609f866..ef612527 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -4,7 +4,7 @@
 calc = ['pyscf',            # pyscf  
         'adf',          # adf 2019 
         'adf2019'               # adf 2020+
-    ][1]
+    ][0]
 
 # select an appropriate basis
 basis = {

From c02b22e7f73cb091f2dc5e1b39315b70352d8dff Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 14:45:13 +0100
Subject: [PATCH 128/286] nmo

---
 .../jastrows/elec_elec/jastrow_factor_electron_electron.py      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 ea097a61..7ec373d7 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -51,7 +51,7 @@ def __init__(
         if orbital_dependent_kernel:
             # default to all orbitals if number_of_orbitals is None
             if number_of_orbitals is None:
-                number_of_orbitals = mol.calculator.basis.nmo
+                number_of_orbitals = mol.basis.nmo
             # create the orbital dependent jastrow
             self.jastrow_kernel = OrbitalDependentJastrowKernel(
                 mol.nup,

From 0a08ee0bff0853f3a821a1e35811630c84c3eeb1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 15:56:23 +0100
Subject: [PATCH 129/286] test jastrow orb dependent skip a few

---
 .../test_slater_orbital_dependent_jastrow.py          | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 1392c61a..90563975 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -54,6 +54,17 @@ def setUp(self):
         self.pos = torch.Tensor(np.random.rand(self.nbatch, self.wf.nelec * 3))
         self.pos.requires_grad = True
 
+    def test_gradients_wf(self):
+        pass
+
+    def test_gradients_pdf(self):
+        pass
+
+    def test_kinetic_energy(self):
+        pass
+
+    def test_local_energy(self):
+        pass
 
 if __name__ == "__main__":
     unittest.main()

From 327e07e30930739cd8212f2636a31b0f847659b4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Nov 2023 16:11:54 +0100
Subject: [PATCH 130/286] removed charge/spin from adf calculator

---
 docs/example/scf/scf.py        | 9 +++++----
 qmctorch/scf/calculator/adf.py | 8 +++++++-
 2 files changed, 12 insertions(+), 5 deletions(-)

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/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 0d9e3f31..91a0ec23 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -32,6 +32,12 @@ def __init__(  # pylint: disable=too-many-arguments
             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"]
 
@@ -128,7 +134,7 @@ def get_plams_settings(self):
         sett.input.adf.totalenergy = True
 
         # charge info
-        sett.input.charge = "%d %d" % (self.charge, self.spin)
+        # sett.input.adf.charge = "%d %d" % (self.charge, self.spin)
 
         # spin info
         sett.input.unrestricted = False

From 2f4c3618776b9585a0ac1c3ebb04442f6530cea8 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 1 Dec 2023 14:39:15 +0100
Subject: [PATCH 131/286] clear up notenooks

---
 docs/notebooks/combining_jastrow.ipynb |  57 +---
 docs/notebooks/correlation.ipynb       | 158 +---------
 docs/notebooks/create_backflow.ipynb   |  67 +---
 docs/notebooks/create_jastrow.ipynb    |   7 -
 docs/notebooks/geoopt.ipynb            | 406 +-----------------------
 docs/notebooks/gpu.ipynb               |  36 +--
 docs/notebooks/molecule.ipynb          | 123 +-------
 docs/notebooks/sampling.ipynb          | 321 ++-----------------
 docs/notebooks/wfopt.ipynb             | 417 ++-----------------------
 9 files changed, 102 insertions(+), 1490 deletions(-)

diff --git a/docs/notebooks/combining_jastrow.ipynb b/docs/notebooks/combining_jastrow.ipynb
index 7bb17f5d..e748f072 100644
--- a/docs/notebooks/combining_jastrow.ipynb
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -12,29 +12,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "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": [
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
@@ -111,38 +91,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
-      "INFO:QMCTorch|  Molecule name       : H2\n",
-      "INFO:QMCTorch|  Number of electrons : 2\n",
-      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
-      "INFO:QMCTorch|  Basis set           : sto-3g\n",
-      "INFO:QMCTorch|  SCF                 : HF\n",
-      "INFO:QMCTorch|  Number of AOs       : 2\n",
-      "INFO:QMCTorch|  Number of MOs       : 2\n",
-      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : MyJastrow\n",
-      "INFO:QMCTorch|  Highest MO included : 2\n",
-      "INFO:QMCTorch|  Configurations      : ground_state\n",
-      "INFO:QMCTorch|  Number of confs     : 1\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 145\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, jastrow=[jastrow_ee, jastrow_en])"
    ]
diff --git a/docs/notebooks/correlation.ipynb b/docs/notebooks/correlation.ipynb
index ef68e3c8..e2dd4069 100644
--- a/docs/notebooks/correlation.ipynb
+++ b/docs/notebooks/correlation.ipynb
@@ -13,7 +13,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -38,29 +38,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "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": [
     "set_torch_double_precision()\n",
     "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
@@ -68,26 +48,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 2\n",
-      "INFO:QMCTorch|  Configurations      : ground_state\n",
-      "INFO:QMCTorch|  Number of confs     : 1\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 18\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
@@ -102,26 +65,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Monte-Carlo Sampler\n",
-      "INFO:QMCTorch|  Number of walkers   : 100\n",
-      "INFO:QMCTorch|  Number of steps     : 500\n",
-      "INFO:QMCTorch|  Step size           : 0.25\n",
-      "INFO:QMCTorch|  Thermalization steps: 0\n",
-      "INFO:QMCTorch|  Decorelation steps  : 1\n",
-      "INFO:QMCTorch|  Walkers init pos    : normal\n",
-      "INFO:QMCTorch|  Move type           : all-elec\n",
-      "INFO:QMCTorch|  Move proba          : normal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
     "                    nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -142,20 +88,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| QMC Solver \n",
-      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
-      "INFO:QMCTorch|  Sampler             : Metropolis\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -172,35 +107,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:46<00:00, 10.68it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|   Acceptance rate     : 62.55 %\n",
-      "INFO:QMCTorch|   Timing statistics   : 10.68 steps/sec.\n",
-      "INFO:QMCTorch|   Total Time          : 46.83 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  Sampling trajectory\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Energy  : 100%|██████████| 500/500 [01:43<00:00,  4.85it/s]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)"
@@ -216,20 +125,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "rho, tau = plot_correlation_coefficient(obs.local_energy)"
    ]
@@ -250,20 +148,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plot_integrated_autocorrelation_time(obs.local_energy)"
    ]
@@ -282,20 +169,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers='mean')"
    ]
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index 103d270f..ee2ab3a9 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -13,28 +13,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Running scf  calculation\n",
-      "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 qmctorch.scf import Molecule\n",
@@ -56,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -100,52 +81,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 2\n",
-      "INFO:QMCTorch|  Configurations      : ground_state\n",
-      "INFO:QMCTorch|  Number of confs     : 1\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 146\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, backflow=backflow)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index 9b286a5b..bfbc4c58 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -146,13 +146,6 @@
    "source": [
     "wf = SlaterJastrow(mol, jastrow=jastrow)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/notebooks/geoopt.ipynb b/docs/notebooks/geoopt.ipynb
index 314f0c1c..73491ee6 100644
--- a/docs/notebooks/geoopt.ipynb
+++ b/docs/notebooks/geoopt.ipynb
@@ -12,20 +12,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  ____    __  ______________             _\n",
-      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
-      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
-      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from torch import optim\n",
     "from torch.optim import Adam\n",
@@ -47,29 +36,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "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": [
     "mol = Molecule(atom = 'H 0. 0. -0.5; H 0. 0. 0.5', unit='bohr', \n",
     "               calculator='pyscf', basis='sto-3g', redo_scf=True)"
@@ -84,47 +53,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 2\n",
-      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
-      "INFO:QMCTorch|  Number of confs     : 4\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 21\n",
-      "INFO:QMCTorch|  Cuda support        : False\n",
-      "INFO:QMCTorch|  Fit GTOs to STOs  : \n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 2\n",
-      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
-      "INFO:QMCTorch|  Number of confs     : 4\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 17\n",
-      "INFO:QMCTorch|  Cuda support        : False\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Monte-Carlo Sampler\n",
-      "INFO:QMCTorch|  Number of walkers   : 1000\n",
-      "INFO:QMCTorch|  Number of steps     : 200\n",
-      "INFO:QMCTorch|  Step size           : 0.5\n",
-      "INFO:QMCTorch|  Thermalization steps: -1\n",
-      "INFO:QMCTorch|  Decorelation steps  : 100\n",
-      "INFO:QMCTorch|  Walkers init pos    : normal\n",
-      "INFO:QMCTorch|  Move type           : all-elec\n",
-      "INFO:QMCTorch|  Move proba          : normal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# wave function with only the ground state determinant\n",
     "wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()\n",
@@ -144,26 +75,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object Solver already exists in H2_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_9\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| QMC Solver \n",
-      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
-      "INFO:QMCTorch|  Sampler             : Metropolis\n",
-      "INFO:QMCTorch|  Optimizer           : Adam\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = Solver(wf=wf,\n",
     "                       sampler=sampler,\n",
@@ -181,292 +95,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  Optimization\n",
-      "INFO:QMCTorch|  Task                :\n",
-      "INFO:QMCTorch|  Number Parameters   : 6\n",
-      "INFO:QMCTorch|  Number of epoch     : 50\n",
-      "INFO:QMCTorch|  Batch size          : 1000\n",
-      "INFO:QMCTorch|  Loss function       : energy\n",
-      "INFO:QMCTorch|  Clip Loss           : False\n",
-      "INFO:QMCTorch|  Gradients           : auto\n",
-      "INFO:QMCTorch|  Resampling mode     : update\n",
-      "INFO:QMCTorch|  Resampling every    : 1\n",
-      "INFO:QMCTorch|  Resampling steps    : 25\n",
-      "INFO:QMCTorch|  Output file         : H2_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch|  Checkpoint every    : None\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 0\n",
-      "INFO:QMCTorch|  energy   : -1.070846 +/- 0.012322\n",
-      "INFO:QMCTorch|  variance : 0.389654\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 1\n",
-      "INFO:QMCTorch|  energy   : -1.093524 +/- 0.012193\n",
-      "INFO:QMCTorch|  variance : 0.385562\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 2\n",
-      "INFO:QMCTorch|  energy   : -1.085855 +/- 0.011676\n",
-      "INFO:QMCTorch|  variance : 0.369217\n",
-      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 3\n",
-      "INFO:QMCTorch|  energy   : -1.095264 +/- 0.011571\n",
-      "INFO:QMCTorch|  variance : 0.365905\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 4\n",
-      "INFO:QMCTorch|  energy   : -1.078411 +/- 0.010946\n",
-      "INFO:QMCTorch|  variance : 0.346155\n",
-      "INFO:QMCTorch|  epoch done in 0.34 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 5\n",
-      "INFO:QMCTorch|  energy   : -1.073701 +/- 0.011750\n",
-      "INFO:QMCTorch|  variance : 0.371554\n",
-      "INFO:QMCTorch|  epoch done in 0.35 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 6\n",
-      "INFO:QMCTorch|  energy   : -1.083239 +/- 0.011441\n",
-      "INFO:QMCTorch|  variance : 0.361785\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 7\n",
-      "INFO:QMCTorch|  energy   : -1.091864 +/- 0.011191\n",
-      "INFO:QMCTorch|  variance : 0.353902\n",
-      "INFO:QMCTorch|  epoch done in 0.13 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 8\n",
-      "INFO:QMCTorch|  energy   : -1.112321 +/- 0.010893\n",
-      "INFO:QMCTorch|  variance : 0.344459\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 9\n",
-      "INFO:QMCTorch|  energy   : -1.101314 +/- 0.011203\n",
-      "INFO:QMCTorch|  variance : 0.354284\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 10\n",
-      "INFO:QMCTorch|  energy   : -1.095483 +/- 0.011385\n",
-      "INFO:QMCTorch|  variance : 0.360013\n",
-      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 11\n",
-      "INFO:QMCTorch|  energy   : -1.120974 +/- 0.010508\n",
-      "INFO:QMCTorch|  variance : 0.332293\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 12\n",
-      "INFO:QMCTorch|  energy   : -1.116147 +/- 0.010295\n",
-      "INFO:QMCTorch|  variance : 0.325555\n",
-      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 13\n",
-      "INFO:QMCTorch|  energy   : -1.090706 +/- 0.011097\n",
-      "INFO:QMCTorch|  variance : 0.350910\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 14\n",
-      "INFO:QMCTorch|  energy   : -1.106975 +/- 0.010232\n",
-      "INFO:QMCTorch|  variance : 0.323554\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 15\n",
-      "INFO:QMCTorch|  energy   : -1.114616 +/- 0.010598\n",
-      "INFO:QMCTorch|  variance : 0.335125\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 16\n",
-      "INFO:QMCTorch|  energy   : -1.120063 +/- 0.009871\n",
-      "INFO:QMCTorch|  variance : 0.312143\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 17\n",
-      "INFO:QMCTorch|  energy   : -1.126814 +/- 0.010350\n",
-      "INFO:QMCTorch|  variance : 0.327289\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 18\n",
-      "INFO:QMCTorch|  energy   : -1.110957 +/- 0.009913\n",
-      "INFO:QMCTorch|  variance : 0.313466\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 19\n",
-      "INFO:QMCTorch|  energy   : -1.135297 +/- 0.009999\n",
-      "INFO:QMCTorch|  variance : 0.316206\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 20\n",
-      "INFO:QMCTorch|  energy   : -1.126248 +/- 0.010025\n",
-      "INFO:QMCTorch|  variance : 0.317012\n",
-      "INFO:QMCTorch|  epoch done in 0.13 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 21\n",
-      "INFO:QMCTorch|  energy   : -1.119559 +/- 0.010067\n",
-      "INFO:QMCTorch|  variance : 0.318341\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 22\n",
-      "INFO:QMCTorch|  energy   : -1.114980 +/- 0.009557\n",
-      "INFO:QMCTorch|  variance : 0.302212\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 23\n",
-      "INFO:QMCTorch|  energy   : -1.122430 +/- 0.010054\n",
-      "INFO:QMCTorch|  variance : 0.317943\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 24\n",
-      "INFO:QMCTorch|  energy   : -1.122087 +/- 0.009651\n",
-      "INFO:QMCTorch|  variance : 0.305191\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 25\n",
-      "INFO:QMCTorch|  energy   : -1.133653 +/- 0.009697\n",
-      "INFO:QMCTorch|  variance : 0.306655\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 26\n",
-      "INFO:QMCTorch|  energy   : -1.153086 +/- 0.009464\n",
-      "INFO:QMCTorch|  variance : 0.299277\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 27\n",
-      "INFO:QMCTorch|  energy   : -1.137196 +/- 0.009235\n",
-      "INFO:QMCTorch|  variance : 0.292042\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 28\n",
-      "INFO:QMCTorch|  energy   : -1.134850 +/- 0.009741\n",
-      "INFO:QMCTorch|  variance : 0.308045\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 29\n",
-      "INFO:QMCTorch|  energy   : -1.137292 +/- 0.008938\n",
-      "INFO:QMCTorch|  variance : 0.282648\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 30\n",
-      "INFO:QMCTorch|  energy   : -1.129972 +/- 0.009542\n",
-      "INFO:QMCTorch|  variance : 0.301736\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 31\n",
-      "INFO:QMCTorch|  energy   : -1.129879 +/- 0.008805\n",
-      "INFO:QMCTorch|  variance : 0.278450\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 32\n",
-      "INFO:QMCTorch|  energy   : -1.120897 +/- 0.009573\n",
-      "INFO:QMCTorch|  variance : 0.302713\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 33\n",
-      "INFO:QMCTorch|  energy   : -1.126543 +/- 0.008883\n",
-      "INFO:QMCTorch|  variance : 0.280912\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 34\n",
-      "INFO:QMCTorch|  energy   : -1.125339 +/- 0.009391\n",
-      "INFO:QMCTorch|  variance : 0.296973\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 35\n",
-      "INFO:QMCTorch|  energy   : -1.132248 +/- 0.009047\n",
-      "INFO:QMCTorch|  variance : 0.286092\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 36\n",
-      "INFO:QMCTorch|  energy   : -1.143987 +/- 0.008693\n",
-      "INFO:QMCTorch|  variance : 0.274895\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 37\n",
-      "INFO:QMCTorch|  energy   : -1.143939 +/- 0.009039\n",
-      "INFO:QMCTorch|  variance : 0.285829\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 38\n",
-      "INFO:QMCTorch|  energy   : -1.132018 +/- 0.008930\n",
-      "INFO:QMCTorch|  variance : 0.282378\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 39\n",
-      "INFO:QMCTorch|  energy   : -1.135228 +/- 0.008902\n",
-      "INFO:QMCTorch|  variance : 0.281495\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 40\n",
-      "INFO:QMCTorch|  energy   : -1.146552 +/- 0.009092\n",
-      "INFO:QMCTorch|  variance : 0.287503\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 41\n",
-      "INFO:QMCTorch|  energy   : -1.141178 +/- 0.008888\n",
-      "INFO:QMCTorch|  variance : 0.281070\n",
-      "INFO:QMCTorch|  epoch done in 0.10 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 42\n",
-      "INFO:QMCTorch|  energy   : -1.133022 +/- 0.009063\n",
-      "INFO:QMCTorch|  variance : 0.286591\n",
-      "INFO:QMCTorch|  epoch done in 0.11 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 43\n",
-      "INFO:QMCTorch|  energy   : -1.133298 +/- 0.008375\n",
-      "INFO:QMCTorch|  variance : 0.264828\n",
-      "INFO:QMCTorch|  epoch done in 0.23 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 44\n",
-      "INFO:QMCTorch|  energy   : -1.135157 +/- 0.008890\n",
-      "INFO:QMCTorch|  variance : 0.281116\n",
-      "INFO:QMCTorch|  epoch done in 0.38 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 45\n",
-      "INFO:QMCTorch|  energy   : -1.143128 +/- 0.008901\n",
-      "INFO:QMCTorch|  variance : 0.281471\n",
-      "INFO:QMCTorch|  epoch done in 0.09 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 46\n",
-      "INFO:QMCTorch|  energy   : -1.148810 +/- 0.008243\n",
-      "INFO:QMCTorch|  variance : 0.260676\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  epoch done in 0.12 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 47\n",
-      "INFO:QMCTorch|  energy   : -1.143023 +/- 0.008719\n",
-      "INFO:QMCTorch|  variance : 0.275712\n",
-      "INFO:QMCTorch|  epoch done in 0.28 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 48\n",
-      "INFO:QMCTorch|  energy   : -1.154847 +/- 0.008289\n",
-      "INFO:QMCTorch|  variance : 0.262111\n",
-      "INFO:QMCTorch|  epoch done in 0.33 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 49\n",
-      "INFO:QMCTorch|  energy   : -1.140911 +/- 0.008209\n",
-      "INFO:QMCTorch|  variance : 0.259583\n",
-      "INFO:QMCTorch|  epoch done in 0.24 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object wf_opt already exists in H2_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to wf_opt_5\n",
-      "INFO:QMCTorch|\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver.set_params_requires_grad(wf_params=False, geo_params=True)\n",
     "obs = solver.run(50)\n"
@@ -474,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -483,20 +114,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plot_energy(obs.local_energy)"
    ]
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
index 9f78957d..33467ea5 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",
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
index d7be2325..46302162 100644
--- a/docs/notebooks/molecule.ipynb
+++ b/docs/notebooks/molecule.ipynb
@@ -11,20 +11,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  ____    __  ______________             _\n",
-      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
-      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
-      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qmctorch.scf import Molecule"
    ]
@@ -51,38 +40,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.06599946214331\n",
-      "INFO:QMCTorch|  Molecule name       : H2\n",
-      "INFO:QMCTorch|  Number of electrons : 2\n",
-      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
-      "INFO:QMCTorch|  Basis set           : sto-3g\n",
-      "INFO:QMCTorch|  SCF                 : HF\n",
-      "INFO:QMCTorch|  Number of AOs       : 2\n",
-      "INFO:QMCTorch|  Number of MOs       : 2\n",
-      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<qmctorch.scf.molecule.Molecule at 0x7f429ed23910>"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', unit='bohr')"
    ]
@@ -97,29 +57,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "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": [
     "mol = Molecule(atom='h2.xyz', unit='bohr', redo_scf=True)"
    ]
@@ -144,28 +84,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Running scf  calculation\n",
-      "converged SCF energy = -1.07589040772972\n",
-      "INFO:QMCTorch|  Molecule name       : H2\n",
-      "INFO:QMCTorch|  Number of electrons : 2\n",
-      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
-      "INFO:QMCTorch|  Basis set           : sto-6g\n",
-      "INFO:QMCTorch|  SCF                 : HF\n",
-      "INFO:QMCTorch|  Number of AOs       : 2\n",
-      "INFO:QMCTorch|  Number of MOs       : 2\n",
-      "INFO:QMCTorch|  SCF Energy          : -1.076 Hartree\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='pyscf', basis='sto-6g', redo_scf=True)"
    ]
@@ -196,19 +117,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Running scf  calculation\n",
-      "[13.04|16:37:54] PLAMS working folder: /home/nico/QMCTorch/notebooks/plams_workdir.002\n",
-      "File ./plams_workdir/HH_dzp/HH_dzp.t21 not found, ADF may have crashed, look into the plams_workdir directory\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "try:\n",
     "    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='adf2019', basis='dzp')\n",
@@ -243,19 +152,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Loading data from LiH_adf_dz.hdf5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "mol = Molecule(load='./hdf5/LiH_adf_dz.hdf5')"
    ]
diff --git a/docs/notebooks/sampling.ipynb b/docs/notebooks/sampling.ipynb
index 448018dc..ba371c71 100644
--- a/docs/notebooks/sampling.ipynb
+++ b/docs/notebooks/sampling.ipynb
@@ -12,20 +12,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  ____    __  ______________             _\n",
-      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
-      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
-      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np \n",
     "import matplotlib.pyplot as plt \n",
@@ -33,7 +22,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"
    ]
   },
   {
@@ -54,19 +43,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Reusing scf results from water_pyscf_sto-3g.hdf5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# define the molecule\n",
     "mol = Molecule(atom='water.xyz', unit='angs',\n",
@@ -87,26 +66,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 7\n",
-      "INFO:QMCTorch|  Configurations      : ground_state\n",
-      "INFO:QMCTorch|  Number of confs     : 1\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 81\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
@@ -121,26 +83,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Monte-Carlo Sampler\n",
-      "INFO:QMCTorch|  Number of walkers   : 100\n",
-      "INFO:QMCTorch|  Number of steps     : 500\n",
-      "INFO:QMCTorch|  Step size           : 0.25\n",
-      "INFO:QMCTorch|  Thermalization steps: -1\n",
-      "INFO:QMCTorch|  Decorelation steps  : 1\n",
-      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
-      "INFO:QMCTorch|  Move type           : all-elec\n",
-      "INFO:QMCTorch|  Move proba          : normal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
     "                     nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -158,25 +103,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object Solver already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_5\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| QMC Solver \n",
-      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
-      "INFO:QMCTorch|  Sampler             : Metropolis\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -192,53 +121,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:46<00:00,  4.70it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|   Acceptance rate     : 2.45 %\n",
-      "INFO:QMCTorch|   Timing statistics   : 4.70 steps/sec.\n",
-      "INFO:QMCTorch|   Total Time          : 106.35 sec.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x7fef4e5ea700>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "pos = sampler(wf.pdf)\n",
     "pos = pos.reshape(100,10,3).cpu().detach().numpy()\n",
@@ -256,26 +141,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Monte-Carlo Sampler\n",
-      "INFO:QMCTorch|  Number of walkers   : 1\n",
-      "INFO:QMCTorch|  Number of steps     : 500\n",
-      "INFO:QMCTorch|  Step size           : 0.25\n",
-      "INFO:QMCTorch|  Thermalization steps: 0\n",
-      "INFO:QMCTorch|  Decorelation steps  : 1\n",
-      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
-      "INFO:QMCTorch|  Move type           : all-elec\n",
-      "INFO:QMCTorch|  Move proba          : normal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sampler_singlewalker = Metropolis(nwalkers=1, nstep=500, step_size=0.25,\n",
     "                     nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -286,55 +154,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [00:20<00:00, 24.27it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|   Acceptance rate     : 3.20 %\n",
-      "INFO:QMCTorch|   Timing statistics   : 24.25 steps/sec.\n",
-      "INFO:QMCTorch|   Total Time          : 20.62 sec.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fef4cdd4c70>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cdd4d30>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cdd4e20>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cdd4f10>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde0040>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde0130>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde0220>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde0310>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde0400>,\n",
-       " <matplotlib.lines.Line2D at 0x7fef4cde04f0>]"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "pos = sampler_singlewalker(wf.pdf)\n",
     "pos = pos.reshape(-1,10,3).detach().numpy()\n",
@@ -352,25 +174,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object Solver already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_6\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| QMC Solver \n",
-      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
-      "INFO:QMCTorch|  Sampler             : Metropolis\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -385,41 +191,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  Single Point Calculation : 100 walkers | 500 steps\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:53<00:00,  4.40it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|   Acceptance rate     : 2.36 %\n",
-      "INFO:QMCTorch|   Timing statistics   : 4.40 steps/sec.\n",
-      "INFO:QMCTorch|   Total Time          : 113.76 sec.\n",
-      "INFO:QMCTorch|  Energy   : -72.750839 +/- 1.374327\n",
-      "INFO:QMCTorch|  Variance : 188.877533\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object single_point already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to single_point_3\n",
-      "INFO:QMCTorch|\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "obs = solver.single_point()"
    ]
@@ -435,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -453,56 +227,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Sampling: 100%|██████████| 500/500 [01:32<00:00,  5.42it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|   Acceptance rate     : 2.76 %\n",
-      "INFO:QMCTorch|   Timing statistics   : 5.42 steps/sec.\n",
-      "INFO:QMCTorch|   Total Time          : 92.22 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  Sampling trajectory\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  Energy  : 100%|██████████| 100/100 [01:06<00:00,  1.50it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object sampling_trajectory already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to sampling_trajectory_3\n",
-      "INFO:QMCTorch|\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)\n",
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
index b262973e..9c90fede 100644
--- a/docs/notebooks/wfopt.ipynb
+++ b/docs/notebooks/wfopt.ipynb
@@ -12,20 +12,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  ____    __  ______________             _\n",
-      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
-      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
-      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from torch import optim\n",
     "from qmctorch.scf import Molecule\n",
@@ -33,7 +22,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()"
    ]
   },
@@ -49,19 +38,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| SCF Calculation\n",
-      "INFO:QMCTorch|  Loading data from ./hdf5/H2_adf_dzp.hdf5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "mol = Molecule(load='./hdf5/H2_adf_dzp.hdf5')"
    ]
@@ -77,26 +56,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : PadeJastrowKernel\n",
-      "INFO:QMCTorch|  Highest MO included : 10\n",
-      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
-      "INFO:QMCTorch|  Number of confs     : 4\n",
-      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
-      "INFO:QMCTorch|  Number var  param   : 121\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, configs='single_double(2,2)')"
    ]
@@ -112,26 +74,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Monte-Carlo Sampler\n",
-      "INFO:QMCTorch|  Number of walkers   : 5000\n",
-      "INFO:QMCTorch|  Number of steps     : 200\n",
-      "INFO:QMCTorch|  Step size           : 0.2\n",
-      "INFO:QMCTorch|  Thermalization steps: -1\n",
-      "INFO:QMCTorch|  Decorelation steps  : 100\n",
-      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
-      "INFO:QMCTorch|  Move type           : all-elec\n",
-      "INFO:QMCTorch|  Move proba          : normal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sampler = Metropolis(nwalkers=5000,\n",
     "                     nstep=200, step_size=0.2,\n",
@@ -150,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,7 +115,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -186,26 +131,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object Solver already exists in H2_adf_dzp_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to SolverSlaterJastrow_7\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| QMC Solver \n",
-      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
-      "INFO:QMCTorch|  Sampler             : Metropolis\n",
-      "INFO:QMCTorch|  Optimizer           : Adam\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)"
    ]
@@ -221,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -238,7 +166,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -254,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -270,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -287,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,322 +236,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  Optimization\n",
-      "INFO:QMCTorch|  Task                :\n",
-      "INFO:QMCTorch|  Number Parameters   : 115\n",
-      "INFO:QMCTorch|  Number of epoch     : 50\n",
-      "INFO:QMCTorch|  Batch size          : 5000\n",
-      "INFO:QMCTorch|  Loss function       : energy\n",
-      "INFO:QMCTorch|  Clip Loss           : False\n",
-      "INFO:QMCTorch|  Gradients           : manual\n",
-      "INFO:QMCTorch|  Resampling mode     : update\n",
-      "INFO:QMCTorch|  Resampling every    : 1\n",
-      "INFO:QMCTorch|  Resampling steps    : 25\n",
-      "INFO:QMCTorch|  Output file         : H2_adf_dzp_QMCTorch.hdf5\n",
-      "INFO:QMCTorch|  Checkpoint every    : None\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 0\n",
-      "INFO:QMCTorch|  energy   : -1.155363 +/- 0.003267\n",
-      "INFO:QMCTorch|  variance : 0.231010\n",
-      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 1\n",
-      "INFO:QMCTorch|  energy   : -1.149161 +/- 0.003279\n",
-      "INFO:QMCTorch|  variance : 0.231844\n",
-      "INFO:QMCTorch|  epoch done in 0.59 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 2\n",
-      "INFO:QMCTorch|  energy   : -1.150710 +/- 0.003106\n",
-      "INFO:QMCTorch|  variance : 0.219625\n",
-      "INFO:QMCTorch|  epoch done in 0.94 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 3\n",
-      "INFO:QMCTorch|  energy   : -1.156548 +/- 0.003170\n",
-      "INFO:QMCTorch|  variance : 0.224149\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 4\n",
-      "INFO:QMCTorch|  energy   : -1.155115 +/- 0.003221\n",
-      "INFO:QMCTorch|  variance : 0.227777\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 5\n",
-      "INFO:QMCTorch|  energy   : -1.156112 +/- 0.003083\n",
-      "INFO:QMCTorch|  variance : 0.217972\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 6\n",
-      "INFO:QMCTorch|  energy   : -1.155542 +/- 0.003070\n",
-      "INFO:QMCTorch|  variance : 0.217062\n",
-      "INFO:QMCTorch|  epoch done in 0.94 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 7\n",
-      "INFO:QMCTorch|  energy   : -1.157297 +/- 0.003046\n",
-      "INFO:QMCTorch|  variance : 0.215387\n",
-      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 8\n",
-      "INFO:QMCTorch|  energy   : -1.150183 +/- 0.003147\n",
-      "INFO:QMCTorch|  variance : 0.222538\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 9\n",
-      "INFO:QMCTorch|  energy   : -1.155700 +/- 0.003062\n",
-      "INFO:QMCTorch|  variance : 0.216530\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 10\n",
-      "INFO:QMCTorch|  energy   : -1.154875 +/- 0.003005\n",
-      "INFO:QMCTorch|  variance : 0.212476\n",
-      "INFO:QMCTorch|  epoch done in 0.60 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 11\n",
-      "INFO:QMCTorch|  energy   : -1.154984 +/- 0.003024\n",
-      "INFO:QMCTorch|  variance : 0.213820\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 12\n",
-      "INFO:QMCTorch|  energy   : -1.154497 +/- 0.002974\n",
-      "INFO:QMCTorch|  variance : 0.210262\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 13\n",
-      "INFO:QMCTorch|  energy   : -1.157227 +/- 0.003000\n",
-      "INFO:QMCTorch|  variance : 0.212123\n",
-      "INFO:QMCTorch|  epoch done in 0.57 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 14\n",
-      "INFO:QMCTorch|  energy   : -1.156778 +/- 0.002914\n",
-      "INFO:QMCTorch|  variance : 0.206054\n",
-      "INFO:QMCTorch|  epoch done in 0.75 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 15\n",
-      "INFO:QMCTorch|  energy   : -1.152052 +/- 0.003022\n",
-      "INFO:QMCTorch|  variance : 0.213717\n",
-      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 16\n",
-      "INFO:QMCTorch|  energy   : -1.158149 +/- 0.002847\n",
-      "INFO:QMCTorch|  variance : 0.201333\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 17\n",
-      "INFO:QMCTorch|  energy   : -1.158337 +/- 0.002852\n",
-      "INFO:QMCTorch|  variance : 0.201654\n",
-      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 18\n",
-      "INFO:QMCTorch|  energy   : -1.158138 +/- 0.002793\n",
-      "INFO:QMCTorch|  variance : 0.197500\n",
-      "INFO:QMCTorch|  epoch done in 0.89 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 19\n",
-      "INFO:QMCTorch|  energy   : -1.157327 +/- 0.002869\n",
-      "INFO:QMCTorch|  variance : 0.202897\n",
-      "INFO:QMCTorch|  epoch done in 0.99 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 20\n",
-      "INFO:QMCTorch|  energy   : -1.155671 +/- 0.002901\n",
-      "INFO:QMCTorch|  variance : 0.205139\n",
-      "INFO:QMCTorch|  epoch done in 0.52 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 21\n",
-      "INFO:QMCTorch|  energy   : -1.156606 +/- 0.002863\n",
-      "INFO:QMCTorch|  variance : 0.202470\n",
-      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 22\n",
-      "INFO:QMCTorch|  energy   : -1.164993 +/- 0.002852\n",
-      "INFO:QMCTorch|  variance : 0.201661\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 23\n",
-      "INFO:QMCTorch|  energy   : -1.157040 +/- 0.002765\n",
-      "INFO:QMCTorch|  variance : 0.195510\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 24\n",
-      "INFO:QMCTorch|  energy   : -1.163667 +/- 0.002707\n",
-      "INFO:QMCTorch|  variance : 0.191386\n",
-      "INFO:QMCTorch|  epoch done in 0.57 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 25\n",
-      "INFO:QMCTorch|  energy   : -1.159113 +/- 0.002700\n",
-      "INFO:QMCTorch|  variance : 0.190943\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 26\n",
-      "INFO:QMCTorch|  energy   : -1.162071 +/- 0.002661\n",
-      "INFO:QMCTorch|  variance : 0.188190\n",
-      "INFO:QMCTorch|  epoch done in 0.53 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 27\n",
-      "INFO:QMCTorch|  energy   : -1.158837 +/- 0.002642\n",
-      "INFO:QMCTorch|  variance : 0.186836\n",
-      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 28\n",
-      "INFO:QMCTorch|  energy   : -1.155956 +/- 0.002649\n",
-      "INFO:QMCTorch|  variance : 0.187284\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 29\n",
-      "INFO:QMCTorch|  energy   : -1.162127 +/- 0.002609\n",
-      "INFO:QMCTorch|  variance : 0.184491\n",
-      "INFO:QMCTorch|  epoch done in 0.73 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 30\n",
-      "INFO:QMCTorch|  energy   : -1.163752 +/- 0.002560\n",
-      "INFO:QMCTorch|  variance : 0.181025\n",
-      "INFO:QMCTorch|  epoch done in 0.52 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 31\n",
-      "INFO:QMCTorch|  energy   : -1.159163 +/- 0.002590\n",
-      "INFO:QMCTorch|  variance : 0.183165\n",
-      "INFO:QMCTorch|  epoch done in 0.56 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 32\n",
-      "INFO:QMCTorch|  energy   : -1.163472 +/- 0.002603\n",
-      "INFO:QMCTorch|  variance : 0.184072\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 33\n",
-      "INFO:QMCTorch|  energy   : -1.165384 +/- 0.002563\n",
-      "INFO:QMCTorch|  variance : 0.181214\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 34\n",
-      "INFO:QMCTorch|  energy   : -1.163774 +/- 0.002527\n",
-      "INFO:QMCTorch|  variance : 0.178661\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 35\n",
-      "INFO:QMCTorch|  energy   : -1.161995 +/- 0.002472\n",
-      "INFO:QMCTorch|  variance : 0.174763\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 36\n",
-      "INFO:QMCTorch|  energy   : -1.161698 +/- 0.002521\n",
-      "INFO:QMCTorch|  variance : 0.178254\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 37\n",
-      "INFO:QMCTorch|  energy   : -1.162856 +/- 0.002532\n",
-      "INFO:QMCTorch|  variance : 0.179051\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 38\n",
-      "INFO:QMCTorch|  energy   : -1.157138 +/- 0.002535\n",
-      "INFO:QMCTorch|  variance : 0.179220\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 39\n",
-      "INFO:QMCTorch|  energy   : -1.163320 +/- 0.002536\n",
-      "INFO:QMCTorch|  variance : 0.179332\n",
-      "INFO:QMCTorch|  epoch done in 0.74 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 40\n",
-      "INFO:QMCTorch|  energy   : -1.161880 +/- 0.002464\n",
-      "INFO:QMCTorch|  variance : 0.174239\n",
-      "INFO:QMCTorch|  epoch done in 0.48 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 41\n",
-      "INFO:QMCTorch|  energy   : -1.158324 +/- 0.002542\n",
-      "INFO:QMCTorch|  variance : 0.179777\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 42\n",
-      "INFO:QMCTorch|  energy   : -1.158298 +/- 0.002442\n",
-      "INFO:QMCTorch|  variance : 0.172696\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 43\n",
-      "INFO:QMCTorch|  energy   : -1.160970 +/- 0.002371\n",
-      "INFO:QMCTorch|  variance : 0.167662\n",
-      "INFO:QMCTorch|  epoch done in 0.79 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 44\n",
-      "INFO:QMCTorch|  energy   : -1.159741 +/- 0.002362\n",
-      "INFO:QMCTorch|  variance : 0.166993\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 45\n",
-      "INFO:QMCTorch|  energy   : -1.162254 +/- 0.002349\n",
-      "INFO:QMCTorch|  variance : 0.166119\n",
-      "INFO:QMCTorch|  epoch done in 0.73 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 46\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:QMCTorch|  energy   : -1.160540 +/- 0.002314\n",
-      "INFO:QMCTorch|  variance : 0.163611\n",
-      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 47\n",
-      "INFO:QMCTorch|  energy   : -1.162938 +/- 0.002316\n",
-      "INFO:QMCTorch|  variance : 0.163749\n",
-      "INFO:QMCTorch|  epoch done in 0.49 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 48\n",
-      "INFO:QMCTorch|  energy   : -1.163674 +/- 0.002214\n",
-      "INFO:QMCTorch|  variance : 0.156522\n",
-      "INFO:QMCTorch|  epoch done in 0.51 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch|  epoch 49\n",
-      "INFO:QMCTorch|  energy   : -1.163112 +/- 0.002278\n",
-      "INFO:QMCTorch|  variance : 0.161065\n",
-      "INFO:QMCTorch|  epoch done in 0.50 sec.\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Warning : dump to hdf5\n",
-      "INFO:QMCTorch| Object wf_opt already exists in H2_adf_dzp_QMCTorch.hdf5\n",
-      "INFO:QMCTorch| Object name changed to wf_opt_7\n",
-      "INFO:QMCTorch|\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "obs = solver.run(50)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

From ece422598a76ebe69545dc526997e1e847467b80 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 09:20:29 +0100
Subject: [PATCH 132/286] clean notebooks

---
 docs/notebooks/create_backflow.ipynb | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index ee2ab3a9..c5d7235f 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -97,13 +97,6 @@
     "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

From 5c0ae26b02cfd8feaeafcfb5baf76eae7e7d3be5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 09:44:29 +0100
Subject: [PATCH 133/286] added doc on gh action

---
 .github/workflows/build.yml | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 4df5f217..c996d565 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -61,6 +61,17 @@ jobs:
         GITHUB_TOKEN: ${{ secrets.github_token }}
         COVERALLS_FLAG_NAME: python-${{ matrix.version }}
         COVERALLS_PARALLEL: true
+    # Standard drop-in approach that should work for most people.
+    - uses: ammaraskar/sphinx-action@master
+      with:
+        docs-folder: "docs/"
+    # Great extra actions to compose with:
+    # Create an artifact of the html output.
+    - uses: actions/upload-artifact@v1
+      with:
+        name: DocumentationHTML
+        path: docs/_build/html/
+    
 
   finish:
     needs: build
@@ -71,3 +82,23 @@ jobs:
         with:
           github-token: ${{ secrets.github_token }}
           parallel-finished: true
+      # Publish built docs to gh-pages branch.
+      # ===============================
+      - name: Commit documentation changes
+        run: |
+          git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
+          cp -r docs/_build/html/* gh-pages/
+          cd gh-pages
+          touch .nojekyll
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add .
+          git commit -m "Update documentation" -a || true
+          # The above command will fail if no changes were present, so we ignore
+          # that.
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          branch: gh-pages
+          directory: gh-pages
+          github_token: ${{ secrets.GITHUB_TOKEN }}

From 44461229a2798c1708b7c1589bd08bb61b3ed772 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 12:19:14 +0100
Subject: [PATCH 134/286] added pandoc install

---
 .github/workflows/build.yml                        | 1 +
 {docs/example/colab => collab}/google_collab.ipynb | 0
 2 files changed, 1 insertion(+)
 rename {docs/example/colab => collab}/google_collab.ipynb (100%)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c996d565..9f04b53a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -34,6 +34,7 @@ jobs:
         conda install rdkit 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
+        conda install pandoc
 
     - name: Install the package
       run: python -m pip install .[test,hpc]
diff --git a/docs/example/colab/google_collab.ipynb b/collab/google_collab.ipynb
similarity index 100%
rename from docs/example/colab/google_collab.ipynb
rename to collab/google_collab.ipynb

From 64d48ea5e058d9f24d45543b4efdfda51ed71308 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 14:33:01 +0100
Subject: [PATCH 135/286] add conda path

---
 .github/workflows/build.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9f04b53a..5e695857 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -66,6 +66,8 @@ jobs:
     - uses: ammaraskar/sphinx-action@master
       with:
         docs-folder: "docs/"
+      env:
+        CONDA_PREFIX: /usr/share/miniconda
     # Great extra actions to compose with:
     # Create an artifact of the html output.
     - uses: actions/upload-artifact@v1

From 43bb0f7e1265489d68e505258cedcd47169b57ac Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 15:04:33 +0100
Subject: [PATCH 136/286] try without sphinx-action

---
 .github/workflows/build.yml               | 42 +++++++++--------------
 {collab => notebooks}/google_collab.ipynb |  0
 setup.py                                  |  2 +-
 3 files changed, 18 insertions(+), 26 deletions(-)
 rename {collab => notebooks}/google_collab.ipynb (100%)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5e695857..65572466 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -27,17 +27,16 @@ jobs:
     - name: Install essential
       run: |
         sudo apt update
-        sudo apt install build-essential
+        sudo apt install build-essential pandoc
     - name: Install conda packages
       run: |
         conda install -c anaconda cmake
         conda install rdkit 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
-        conda install pandoc
 
     - name: Install the package
-      run: python -m pip install .[test,hpc]
+      run: python -m pip install .[test,hpc,doc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 
@@ -62,34 +61,13 @@ jobs:
         GITHUB_TOKEN: ${{ secrets.github_token }}
         COVERALLS_FLAG_NAME: python-${{ matrix.version }}
         COVERALLS_PARALLEL: true
-    # Standard drop-in approach that should work for most people.
-    - uses: ammaraskar/sphinx-action@master
-      with:
-        docs-folder: "docs/"
-      env:
-        CONDA_PREFIX: /usr/share/miniconda
-    # Great extra actions to compose with:
-    # Create an artifact of the html output.
-    - uses: actions/upload-artifact@v1
-      with:
-        name: DocumentationHTML
-        path: docs/_build/html/
-    
 
-  finish:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Coveralls Finished
-        uses: coverallsapp/github-action@master
-        with:
-          github-token: ${{ secrets.github_token }}
-          parallel-finished: true
       # Publish built docs to gh-pages branch.
       # ===============================
       - name: Commit documentation changes
         run: |
           git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
+          jupyter nbconvert --to notebook --execute docs/notebooks/sampling.ipynb
           cp -r docs/_build/html/* gh-pages/
           cd gh-pages
           touch .nojekyll
@@ -99,9 +77,23 @@ jobs:
           git commit -m "Update documentation" -a || true
           # The above command will fail if no changes were present, so we ignore
           # that.
+        env:
+          CONDA_PREFIX: /usr/share/miniconda
       - name: Push changes
         uses: ad-m/github-push-action@master
         with:
           branch: gh-pages
           directory: gh-pages
           github_token: ${{ secrets.GITHUB_TOKEN }}
+    
+
+  finish:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.github_token }}
+          parallel-finished: true
+
diff --git a/collab/google_collab.ipynb b/notebooks/google_collab.ipynb
similarity index 100%
rename from collab/google_collab.ipynb
rename to notebooks/google_collab.ipynb
diff --git a/setup.py b/setup.py
index 20159170..06835d92 100644
--- a/setup.py
+++ b/setup.py
@@ -48,7 +48,7 @@
 
     extras_require={
         'hpc': ['horovod==0.27.0'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx'],
+        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],
     }

From 175c4c75c29ea6568ec2fe9545fb9b5286e0b26c Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 15:18:50 +0100
Subject: [PATCH 137/286] coverage

---
 .github/workflows/build.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 65572466..5bba4568 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -51,9 +51,9 @@ jobs:
       run: coverage run -m pytest tests
 
     - name: Combine all coverage results
-      run: coverage combine
-
-    - run: coverage report
+      run: |
+        coverage combine
+        coverage report
 
     - name: Coveralls Parallel
       run: coveralls --service=github

From 66f22abf46bd52d86d06a838bdc67e65c4664e03 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 15:24:40 +0100
Subject: [PATCH 138/286] fix yaml

---
 .github/workflows/build.yml | 47 ++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5bba4568..5c0cef49 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -54,7 +54,6 @@ jobs:
       run: |
         coverage combine
         coverage report
-
     - name: Coveralls Parallel
       run: coveralls --service=github
       env:
@@ -62,29 +61,29 @@ jobs:
         COVERALLS_FLAG_NAME: python-${{ matrix.version }}
         COVERALLS_PARALLEL: true
 
-      # Publish built docs to gh-pages branch.
-      # ===============================
-      - name: Commit documentation changes
-        run: |
-          git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
-          jupyter nbconvert --to notebook --execute docs/notebooks/sampling.ipynb
-          cp -r docs/_build/html/* gh-pages/
-          cd gh-pages
-          touch .nojekyll
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          git add .
-          git commit -m "Update documentation" -a || true
-          # The above command will fail if no changes were present, so we ignore
-          # that.
-        env:
-          CONDA_PREFIX: /usr/share/miniconda
-      - name: Push changes
-        uses: ad-m/github-push-action@master
-        with:
-          branch: gh-pages
-          directory: gh-pages
-          github_token: ${{ secrets.GITHUB_TOKEN }}
+    # Publish built docs to gh-pages branch.
+    # ===============================
+    - name: Commit documentation changes
+      run: |
+        git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
+        jupyter nbconvert --to notebook --execute docs/notebooks/sampling.ipynb
+        cp -r docs/_build/html/* gh-pages/
+        cd gh-pages
+        touch .nojekyll
+        git config --local user.email "action@github.com"
+        git config --local user.name "GitHub Action"
+        git add .
+        git commit -m "Update documentation" -a || true
+        # The above command will fail if no changes were present, so we ignore
+        # that.
+      env:
+        CONDA_PREFIX: /usr/share/miniconda
+    - name: Push changes
+      uses: ad-m/github-push-action@master
+      with:
+        branch: gh-pages
+        directory: gh-pages
+        github_token: ${{ secrets.GITHUB_TOKEN }}
     
 
   finish:

From 21fa673b2ee3ab6c8c19f56481441a84ccaec7d1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 4 Dec 2023 15:44:46 +0100
Subject: [PATCH 139/286] revert to sphinx-action

---
 .github/workflows/build.yml | 60 ++++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5c0cef49..ae3ae99a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -51,39 +51,26 @@ jobs:
       run: coverage run -m pytest tests
 
     - name: Combine all coverage results
-      run: |
-        coverage combine
-        coverage report
+      run: coverage combine
+
+    - run: coverage report
+
     - name: Coveralls Parallel
       run: coveralls --service=github
       env:
         GITHUB_TOKEN: ${{ secrets.github_token }}
         COVERALLS_FLAG_NAME: python-${{ matrix.version }}
         COVERALLS_PARALLEL: true
-
-    # Publish built docs to gh-pages branch.
-    # ===============================
-    - name: Commit documentation changes
-      run: |
-        git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
-        jupyter nbconvert --to notebook --execute docs/notebooks/sampling.ipynb
-        cp -r docs/_build/html/* gh-pages/
-        cd gh-pages
-        touch .nojekyll
-        git config --local user.email "action@github.com"
-        git config --local user.name "GitHub Action"
-        git add .
-        git commit -m "Update documentation" -a || true
-        # The above command will fail if no changes were present, so we ignore
-        # that.
-      env:
-        CONDA_PREFIX: /usr/share/miniconda
-    - name: Push changes
-      uses: ad-m/github-push-action@master
+    # Standard drop-in approach that should work for most people.
+    - uses: ammaraskar/sphinx-action@master
+      with:
+        docs-folder: "docs/"
+    # Great extra actions to compose with:
+    # Create an artifact of the html output.
+    - uses: actions/upload-artifact@v1
       with:
-        branch: gh-pages
-        directory: gh-pages
-        github_token: ${{ secrets.GITHUB_TOKEN }}
+        name: DocumentationHTML
+        path: docs/_build/html/
     
 
   finish:
@@ -95,4 +82,23 @@ jobs:
         with:
           github-token: ${{ secrets.github_token }}
           parallel-finished: true
-
+      # Publish built docs to gh-pages branch.
+      # ===============================
+      - name: Commit documentation changes
+        run: |
+          git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
+          cp -r docs/_build/html/* gh-pages/
+          cd gh-pages
+          touch .nojekyll
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add .
+          git commit -m "Update documentation" -a || true
+          # The above command will fail if no changes were present, so we ignore
+          # that.
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          branch: gh-pages
+          directory: gh-pages
+          github_token: ${{ secrets.GITHUB_TOKEN }}

From 37bc31af75e71ec1e8a6ef5fbb6bce4291f0a241 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:53:30 +0100
Subject: [PATCH 140/286] execute notebooks

---
 docs/notebooks/clean_notebooks.sh      |  13 +
 docs/notebooks/combining_jastrow.ipynb |  97 +++++-
 docs/notebooks/correlation.ipynb       | 194 ++++++++++--
 docs/notebooks/create_backflow.ipynb   |  81 ++++-
 docs/notebooks/create_jastrow.ipynb    | 107 +++++--
 docs/notebooks/geoopt.ipynb            | 393 +++++++++++++++++++++++-
 docs/notebooks/gpu.ipynb               |   3 +-
 docs/notebooks/h2_traj.xyz             | 255 ++++++++++++++++
 docs/notebooks/molecule.ipynb          | 185 +++++++++--
 docs/notebooks/sampling.ipynb          | 328 ++++++++++++++++++--
 docs/notebooks/wfopt.ipynb             | 406 +++++++++++++++++++++++--
 11 files changed, 1886 insertions(+), 176 deletions(-)
 create mode 100644 docs/notebooks/clean_notebooks.sh
 create mode 100644 docs/notebooks/h2_traj.xyz

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
index e748f072..2861fd47 100644
--- a/docs/notebooks/combining_jastrow.ipynb
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -12,10 +12,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "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": [
+    "import torch\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "\n",
@@ -48,9 +60,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "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",
@@ -70,7 +102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -91,17 +123,61 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "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": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -116,9 +192,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/correlation.ipynb b/docs/notebooks/correlation.ipynb
index e2dd4069..876ee1eb 100644
--- a/docs/notebooks/correlation.ipynb
+++ b/docs/notebooks/correlation.ipynb
@@ -13,17 +13,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "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,19 +49,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_dzp.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\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           : 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.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": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "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      : 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   : 122\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
    "source": [
     "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
@@ -65,9 +113,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 100\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: 0\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : normal\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
    "source": [
     "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
     "                    nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -88,9 +153,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -107,9 +183,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 231.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Energy  : 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 177.86it/s]\n"
+     ]
+    }
+   ],
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)"
@@ -125,9 +227,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "rho, tau = plot_correlation_coefficient(obs.local_energy)"
    ]
@@ -148,9 +261,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "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": [
     "plot_integrated_autocorrelation_time(obs.local_energy)"
    ]
@@ -169,9 +303,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers='mean')"
    ]
@@ -187,7 +332,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -202,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 c5d7235f..a6f3f11f 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -13,9 +13,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "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",
+      "[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      : 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": [
     "import torch\n",
     "from qmctorch.scf import Molecule\n",
@@ -37,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -64,7 +88,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -81,18 +105,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "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      : 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   : 134\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
    "source": [
     "wf = SlaterJastrow(mol, backflow=backflow)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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"
+     ]
+    }
+   ],
    "source": [
     "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
@@ -101,7 +159,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -116,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 bfbc4c58..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,26 +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.jastrow_factor_electron_electron import JastrowFactorElectronElectron\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)"
    ]
   },
   {
@@ -55,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -94,7 +114,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -118,27 +138,15 @@
      "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"
      ]
     }
@@ -146,11 +154,45 @@
    "source": [
     "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))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -165,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 73491ee6..f47d6c37 100644
--- a/docs/notebooks/geoopt.ipynb
+++ b/docs/notebooks/geoopt.ipynb
@@ -12,9 +12,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "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 torch import optim\n",
     "from torch.optim import Adam\n",
@@ -22,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()"
    ]
@@ -36,9 +47,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\n",
+      "converged SCF energy = -1.06599946214331\n",
+      "INFO:QMCTorch|  Molecule name       : H2\n",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-3g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.066 Hartree\n"
+     ]
+    }
+   ],
    "source": [
     "mol = Molecule(atom = 'H 0. 0. -0.5; H 0. 0. 0.5', unit='bohr', \n",
     "               calculator='pyscf', basis='sto-3g', redo_scf=True)"
@@ -53,9 +83,47 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "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      : 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",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 21\n",
+      "INFO:QMCTorch|  Cuda support        : False\n",
+      "INFO:QMCTorch|  Fit GTOs to STOs  : \n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Wave Function\n",
+      "INFO:QMCTorch|  Jastrow factor      : True\n",
+      "INFO:QMCTorch|  Jastrow kernel      : 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",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 17\n",
+      "INFO:QMCTorch|  Cuda support        : False\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 1000\n",
+      "INFO:QMCTorch|  Number of steps     : 200\n",
+      "INFO:QMCTorch|  Step size           : 0.5\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 100\n",
+      "INFO:QMCTorch|  Walkers init pos    : normal\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
    "source": [
     "# wave function with only the ground state determinant\n",
     "wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()\n",
@@ -75,9 +143,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n",
+      "INFO:QMCTorch|  Optimizer           : Adam\n"
+     ]
+    }
+   ],
    "source": [
     "solver = Solver(wf=wf,\n",
     "                       sampler=sampler,\n",
@@ -95,9 +175,281 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Optimization\n",
+      "INFO:QMCTorch|  Task                :\n",
+      "INFO:QMCTorch|  Number Parameters   : 6\n",
+      "INFO:QMCTorch|  Number of epoch     : 50\n",
+      "INFO:QMCTorch|  Batch size          : 1000\n",
+      "INFO:QMCTorch|  Loss function       : energy\n",
+      "INFO:QMCTorch|  Clip Loss           : False\n",
+      "INFO:QMCTorch|  Gradients           : auto\n",
+      "INFO:QMCTorch|  Resampling mode     : update\n",
+      "INFO:QMCTorch|  Resampling every    : 1\n",
+      "INFO:QMCTorch|  Resampling steps    : 25\n",
+      "INFO:QMCTorch|  Output file         : H2_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch|  Checkpoint every    : None\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 0 | 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 | 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 | 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 | 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 | 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 | 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 | 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 | 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 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"
+     ]
+    }
+   ],
    "source": [
     "solver.set_params_requires_grad(wf_params=False, geo_params=True)\n",
     "obs = solver.run(50)\n"
@@ -105,7 +457,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -114,9 +466,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plot_energy(obs.local_energy)"
    ]
@@ -142,5 +505,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
index 33467ea5..3f49e7fc 100644
--- a/docs/notebooks/gpu.ipynb
+++ b/docs/notebooks/gpu.ipynb
@@ -76,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/h2_traj.xyz b/docs/notebooks/h2_traj.xyz
new file mode 100644
index 00000000..501ba0e7
--- /dev/null
+++ b/docs/notebooks/h2_traj.xyz
@@ -0,0 +1,255 @@
+2 
+
+H  0.00000  0.00000 -0.26459
+H  0.00000  0.00000 0.26459
+
+2 
+
+H  0.00000  0.00000 -0.26459
+H  0.00000  0.00000 0.26459
+
+2 
+
+H  0.00265  0.00265 -0.26723
+H  0.00265  0.00265 0.26723
+
+2 
+
+H  0.00113  0.00529 -0.26988
+H  0.00517  0.00510 0.26988
+
+2 
+
+H -0.00089  0.00794 -0.27251
+H  0.00755  0.00745 0.27251
+
+2 
+
+H -0.00273  0.00955 -0.27514
+H  0.00922  0.00759 0.27513
+
+2 
+
+H -0.00461  0.01132 -0.27776
+H  0.01066  0.00729 0.27774
+
+2 
+
+H -0.00600  0.01235 -0.28036
+H  0.01208  0.00658 0.28032
+
+2 
+
+H -0.00658  0.01138 -0.28296
+H  0.01323  0.00618 0.28288
+
+2 
+
+H -0.00784  0.01056 -0.28554
+H  0.01276  0.00744 0.28546
+
+2 
+
+H -0.00951  0.01046 -0.28809
+H  0.01235  0.00856 0.28802
+
+2 
+
+H -0.01141  0.01031 -0.29062
+H  0.01198  0.00955 0.29056
+
+2 
+
+H -0.01322  0.00968 -0.29314
+H  0.01163  0.01044 0.29306
+
+2 
+
+H -0.01507  0.00960 -0.29565
+H  0.01140  0.01123 0.29553
+
+2 
+
+H -0.01717  0.00922 -0.29814
+H  0.01107  0.01195 0.29796
+
+2 
+
+H -0.01914  0.00913 -0.30062
+H  0.01084  0.01261 0.30037
+
+2 
+
+H -0.02113  0.00894 -0.30309
+H  0.01068  0.01320 0.30277
+
+2 
+
+H -0.02306  0.00875 -0.30554
+H  0.01056  0.01375 0.30515
+
+2 
+
+H -0.02501  0.00752 -0.30796
+H  0.01062  0.01425 0.30749
+
+2 
+
+H -0.02703  0.00635 -0.31034
+H  0.01092  0.01470 0.30979
+
+2 
+
+H -0.02914  0.00515 -0.31270
+H  0.01127  0.01514 0.31204
+
+2 
+
+H -0.03126  0.00436 -0.31502
+H  0.01171  0.01555 0.31428
+
+2 
+
+H -0.03319  0.00352 -0.31729
+H  0.01211  0.01598 0.31651
+
+2 
+
+H -0.03517  0.00269 -0.31954
+H  0.01248  0.01638 0.31872
+
+2 
+
+H -0.03710  0.00272 -0.32176
+H  0.01289  0.01675 0.32088
+
+2 
+
+H -0.03898  0.00271 -0.32396
+H  0.01357  0.01703 0.32303
+
+2 
+
+H -0.04102  0.00279 -0.32613
+H  0.01430  0.01732 0.32514
+
+2 
+
+H -0.04282  0.00273 -0.32827
+H  0.01507  0.01761 0.32722
+
+2 
+
+H -0.04455  0.00257 -0.33039
+H  0.01587  0.01787 0.32926
+
+2 
+
+H -0.04639  0.00234 -0.33248
+H  0.01663  0.01813 0.33126
+
+2 
+
+H -0.04816  0.00215 -0.33455
+H  0.01752  0.01830 0.33326
+
+2 
+
+H -0.04990  0.00206 -0.33658
+H  0.01841  0.01849 0.33523
+
+2 
+
+H -0.05179  0.00190 -0.33857
+H  0.01922  0.01866 0.33717
+
+2 
+
+H -0.05372  0.00169 -0.34052
+H  0.02005  0.01882 0.33910
+
+2 
+
+H -0.05569  0.00148 -0.34246
+H  0.02091  0.01899 0.34101
+
+2 
+
+H -0.05787  0.00133 -0.34435
+H  0.02181  0.01915 0.34286
+
+2 
+
+H -0.06009  0.00129 -0.34622
+H  0.02271  0.01931 0.34467
+
+2 
+
+H -0.05900  0.00250 -0.34781
+H  0.02370  0.01946 0.34643
+
+2 
+
+H -0.05802  0.00368 -0.34939
+H  0.02444  0.01965 0.34815
+
+2 
+
+H -0.05717  0.00473 -0.35096
+H  0.02520  0.01985 0.34984
+
+2 
+
+H -0.05639  0.00574 -0.35252
+H  0.02576  0.02013 0.35149
+
+2 
+
+H -0.05573  0.00663 -0.35406
+H  0.02638  0.02036 0.35312
+
+2 
+
+H -0.05518  0.00737 -0.35560
+H  0.02704  0.02059 0.35472
+
+2 
+
+H -0.05473  0.00802 -0.35712
+H  0.02772  0.02080 0.35631
+
+2 
+
+H -0.05440  0.00858 -0.35863
+H  0.02839  0.02100 0.35786
+
+2 
+
+H -0.05417  0.00889 -0.36012
+H  0.02906  0.02119 0.35940
+
+2 
+
+H -0.05402  0.00906 -0.36158
+H  0.02973  0.02136 0.36090
+
+2 
+
+H -0.05394  0.00921 -0.36302
+H  0.03042  0.02153 0.36238
+
+2 
+
+H -0.05392  0.00928 -0.36444
+H  0.03110  0.02166 0.36385
+
+2 
+
+H -0.05392  0.00929 -0.36584
+H  0.03171  0.02176 0.36529
+
+2 
+
+H -0.05397  0.00930 -0.36723
+H  0.03232  0.02188 0.36672
+
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
index 46302162..99710989 100644
--- a/docs/notebooks/molecule.ipynb
+++ b/docs/notebooks/molecule.ipynb
@@ -11,9 +11,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 1,
+   "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",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  ____    __  ______________             _\n",
+      "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
+      "INFO:QMCTorch|/ /_/ / / /|_/ / /__  / / / _ \\/ __/ __/ _ \\ \n",
+      "INFO:QMCTorch|\\___\\_\\/_/  /_/\\___/ /_/  \\___/_/  \\__/_//_/ \n"
+     ]
+    }
+   ],
    "source": [
     "from qmctorch.scf import Molecule"
    ]
@@ -40,11 +58,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 2,
+   "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",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Reusing scf results from H2_pyscf_dzp.hdf5\n"
+     ]
+    }
+   ],
    "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')"
    ]
   },
   {
@@ -57,11 +92,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "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",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Removing H2_pyscf_dzp.hdf5 and redo SCF calculations\n",
+      "INFO:QMCTorch|  Running scf  calculation\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           : 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.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)"
    ]
   },
   {
@@ -84,9 +146,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "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",
+     "output_type": "stream",
+     "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",
+      "INFO:QMCTorch|  Number of electrons : 2\n",
+      "INFO:QMCTorch|  SCF calculator      : pyscf\n",
+      "INFO:QMCTorch|  Basis set           : sto-6g\n",
+      "INFO:QMCTorch|  SCF                 : HF\n",
+      "INFO:QMCTorch|  Number of AOs       : 2\n",
+      "INFO:QMCTorch|  Number of MOs       : 2\n",
+      "INFO:QMCTorch|  SCF Energy          : -1.076 Hartree\n"
+     ]
+    }
+   ],
    "source": [
     "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='pyscf', basis='sto-6g', redo_scf=True)"
    ]
@@ -107,20 +196,46 @@
     "### 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": {},
-   "outputs": [],
+   "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",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Running scf  calculation\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)"
    ]
@@ -152,9 +267,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "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",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Loading data from ./hdf5/LiH_adf_dz.hdf5\n"
+     ]
+    }
+   ],
    "source": [
     "mol = Molecule(load='./hdf5/LiH_adf_dz.hdf5')"
    ]
@@ -162,7 +294,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -177,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 ba371c71..d1b83cfb 100644
--- a/docs/notebooks/sampling.ipynb
+++ b/docs/notebooks/sampling.ipynb
@@ -12,9 +12,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "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": [
     "import numpy as np \n",
     "import matplotlib.pyplot as plt \n",
@@ -43,9 +54,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\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"
+     ]
+    }
+   ],
    "source": [
     "# define the molecule\n",
     "mol = Molecule(atom='water.xyz', unit='angs',\n",
@@ -66,9 +96,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "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      : ee -> PadeJastrowKernel\n",
+      "INFO:QMCTorch|  Highest MO included : 7\n",
+      "INFO:QMCTorch|  Configurations      : ground_state\n",
+      "INFO:QMCTorch|  Number of confs     : 1\n",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 81\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
    "source": [
     "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
@@ -83,9 +130,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 100\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
    "source": [
     "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
     "                     nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -103,9 +167,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -121,9 +196,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 187.74it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|   Acceptance rate     : 2.66 %\n",
+      "INFO:QMCTorch|   Timing statistics   : 187.66 steps/sec.\n",
+      "INFO:QMCTorch|   Total Time          : 2.66 sec.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7fa882af5610>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "pos = sampler(wf.pdf)\n",
     "pos = pos.reshape(100,10,3).cpu().detach().numpy()\n",
@@ -141,9 +260,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 1\n",
+      "INFO:QMCTorch|  Number of steps     : 500\n",
+      "INFO:QMCTorch|  Step size           : 0.25\n",
+      "INFO:QMCTorch|  Thermalization steps: 0\n",
+      "INFO:QMCTorch|  Decorelation steps  : 1\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
    "source": [
     "sampler_singlewalker = Metropolis(nwalkers=1, nstep=500, step_size=0.25,\n",
     "                     nelec=wf.nelec, ndim=wf.ndim,\n",
@@ -154,9 +290,62 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:00<00:00, 897.20it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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 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,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "pos = sampler_singlewalker(wf.pdf)\n",
     "pos = pos.reshape(-1,10,3).detach().numpy()\n",
@@ -174,9 +363,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Warning : dump to hdf5\n",
+      "INFO:QMCTorch| Object Solver already exists in water_pyscf_sto-3g_QMCTorch.hdf5\n",
+      "INFO:QMCTorch| Object name changed to Solver_2\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n"
+     ]
+    }
+   ],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler)"
    ]
@@ -191,9 +396,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Single Point Calculation : 100 walkers | 500 steps\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Sampling: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:00<00:00, 535.45it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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"
+     ]
+    }
+   ],
    "source": [
     "obs = solver.single_point()"
    ]
@@ -209,7 +448,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -227,9 +466,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "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.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"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|  Energy  : 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:01<00:00, 56.11it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)\n",
@@ -239,7 +514,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qmctorch",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -254,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 9c90fede..214b5a9c 100644
--- a/docs/notebooks/wfopt.ipynb
+++ b/docs/notebooks/wfopt.ipynb
@@ -12,9 +12,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "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 torch import optim\n",
     "from qmctorch.scf import Molecule\n",
@@ -38,9 +49,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| SCF Calculation\n",
+      "INFO:QMCTorch|  Loading data from ./hdf5/H2_adf_dzp.hdf5\n"
+     ]
+    }
+   ],
    "source": [
     "mol = Molecule(load='./hdf5/H2_adf_dzp.hdf5')"
    ]
@@ -56,9 +77,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "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      : 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",
+      "INFO:QMCTorch|  Kinetic energy      : jacobi\n",
+      "INFO:QMCTorch|  Number var  param   : 121\n",
+      "INFO:QMCTorch|  Cuda support        : False\n"
+     ]
+    }
+   ],
    "source": [
     "wf = SlaterJastrow(mol, configs='single_double(2,2)')"
    ]
@@ -74,9 +112,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| Monte-Carlo Sampler\n",
+      "INFO:QMCTorch|  Number of walkers   : 5000\n",
+      "INFO:QMCTorch|  Number of steps     : 200\n",
+      "INFO:QMCTorch|  Step size           : 0.2\n",
+      "INFO:QMCTorch|  Thermalization steps: -1\n",
+      "INFO:QMCTorch|  Decorelation steps  : 100\n",
+      "INFO:QMCTorch|  Walkers init pos    : atomic\n",
+      "INFO:QMCTorch|  Move type           : all-elec\n",
+      "INFO:QMCTorch|  Move proba          : normal\n"
+     ]
+    }
+   ],
    "source": [
     "sampler = Metropolis(nwalkers=5000,\n",
     "                     nstep=200, step_size=0.2,\n",
@@ -95,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -115,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -131,9 +186,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch| QMC Solver \n",
+      "INFO:QMCTorch|  WaveFunction        : SlaterJastrow\n",
+      "INFO:QMCTorch|  Sampler             : Metropolis\n",
+      "INFO:QMCTorch|  Optimizer           : Adam\n"
+     ]
+    }
+   ],
    "source": [
     "solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)"
    ]
@@ -142,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": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -166,7 +233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -190,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": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -215,7 +283,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -236,21 +304,311 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  Optimization\n",
+      "INFO:QMCTorch|  Task                :\n",
+      "INFO:QMCTorch|  Number Parameters   : 115\n",
+      "INFO:QMCTorch|  Number of epoch     : 50\n",
+      "INFO:QMCTorch|  Batch size          : 5000\n",
+      "INFO:QMCTorch|  Loss function       : energy\n",
+      "INFO:QMCTorch|  Clip Loss           : False\n",
+      "INFO:QMCTorch|  Gradients           : manual\n",
+      "INFO:QMCTorch|  Resampling mode     : update\n",
+      "INFO:QMCTorch|  Resampling every    : 1\n",
+      "INFO:QMCTorch|  Resampling steps    : 25\n",
+      "INFO:QMCTorch|  Output file         : H2_adf_dzp_QMCTorch.hdf5\n",
+      "INFO:QMCTorch|  Checkpoint every    : None\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|\n",
+      "INFO:QMCTorch|  epoch 0 | 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"
+     ]
+    }
+   ],
    "source": [
     "obs = solver.run(50)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -273,5 +631,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

From 4579c484ef706a08d21611a92437b63cb5e32402 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:53:54 +0100
Subject: [PATCH 141/286] removed h2 traj

---
 docs/notebooks/h2_traj.xyz | 255 -------------------------------------
 1 file changed, 255 deletions(-)
 delete mode 100644 docs/notebooks/h2_traj.xyz

diff --git a/docs/notebooks/h2_traj.xyz b/docs/notebooks/h2_traj.xyz
deleted file mode 100644
index 501ba0e7..00000000
--- a/docs/notebooks/h2_traj.xyz
+++ /dev/null
@@ -1,255 +0,0 @@
-2 
-
-H  0.00000  0.00000 -0.26459
-H  0.00000  0.00000 0.26459
-
-2 
-
-H  0.00000  0.00000 -0.26459
-H  0.00000  0.00000 0.26459
-
-2 
-
-H  0.00265  0.00265 -0.26723
-H  0.00265  0.00265 0.26723
-
-2 
-
-H  0.00113  0.00529 -0.26988
-H  0.00517  0.00510 0.26988
-
-2 
-
-H -0.00089  0.00794 -0.27251
-H  0.00755  0.00745 0.27251
-
-2 
-
-H -0.00273  0.00955 -0.27514
-H  0.00922  0.00759 0.27513
-
-2 
-
-H -0.00461  0.01132 -0.27776
-H  0.01066  0.00729 0.27774
-
-2 
-
-H -0.00600  0.01235 -0.28036
-H  0.01208  0.00658 0.28032
-
-2 
-
-H -0.00658  0.01138 -0.28296
-H  0.01323  0.00618 0.28288
-
-2 
-
-H -0.00784  0.01056 -0.28554
-H  0.01276  0.00744 0.28546
-
-2 
-
-H -0.00951  0.01046 -0.28809
-H  0.01235  0.00856 0.28802
-
-2 
-
-H -0.01141  0.01031 -0.29062
-H  0.01198  0.00955 0.29056
-
-2 
-
-H -0.01322  0.00968 -0.29314
-H  0.01163  0.01044 0.29306
-
-2 
-
-H -0.01507  0.00960 -0.29565
-H  0.01140  0.01123 0.29553
-
-2 
-
-H -0.01717  0.00922 -0.29814
-H  0.01107  0.01195 0.29796
-
-2 
-
-H -0.01914  0.00913 -0.30062
-H  0.01084  0.01261 0.30037
-
-2 
-
-H -0.02113  0.00894 -0.30309
-H  0.01068  0.01320 0.30277
-
-2 
-
-H -0.02306  0.00875 -0.30554
-H  0.01056  0.01375 0.30515
-
-2 
-
-H -0.02501  0.00752 -0.30796
-H  0.01062  0.01425 0.30749
-
-2 
-
-H -0.02703  0.00635 -0.31034
-H  0.01092  0.01470 0.30979
-
-2 
-
-H -0.02914  0.00515 -0.31270
-H  0.01127  0.01514 0.31204
-
-2 
-
-H -0.03126  0.00436 -0.31502
-H  0.01171  0.01555 0.31428
-
-2 
-
-H -0.03319  0.00352 -0.31729
-H  0.01211  0.01598 0.31651
-
-2 
-
-H -0.03517  0.00269 -0.31954
-H  0.01248  0.01638 0.31872
-
-2 
-
-H -0.03710  0.00272 -0.32176
-H  0.01289  0.01675 0.32088
-
-2 
-
-H -0.03898  0.00271 -0.32396
-H  0.01357  0.01703 0.32303
-
-2 
-
-H -0.04102  0.00279 -0.32613
-H  0.01430  0.01732 0.32514
-
-2 
-
-H -0.04282  0.00273 -0.32827
-H  0.01507  0.01761 0.32722
-
-2 
-
-H -0.04455  0.00257 -0.33039
-H  0.01587  0.01787 0.32926
-
-2 
-
-H -0.04639  0.00234 -0.33248
-H  0.01663  0.01813 0.33126
-
-2 
-
-H -0.04816  0.00215 -0.33455
-H  0.01752  0.01830 0.33326
-
-2 
-
-H -0.04990  0.00206 -0.33658
-H  0.01841  0.01849 0.33523
-
-2 
-
-H -0.05179  0.00190 -0.33857
-H  0.01922  0.01866 0.33717
-
-2 
-
-H -0.05372  0.00169 -0.34052
-H  0.02005  0.01882 0.33910
-
-2 
-
-H -0.05569  0.00148 -0.34246
-H  0.02091  0.01899 0.34101
-
-2 
-
-H -0.05787  0.00133 -0.34435
-H  0.02181  0.01915 0.34286
-
-2 
-
-H -0.06009  0.00129 -0.34622
-H  0.02271  0.01931 0.34467
-
-2 
-
-H -0.05900  0.00250 -0.34781
-H  0.02370  0.01946 0.34643
-
-2 
-
-H -0.05802  0.00368 -0.34939
-H  0.02444  0.01965 0.34815
-
-2 
-
-H -0.05717  0.00473 -0.35096
-H  0.02520  0.01985 0.34984
-
-2 
-
-H -0.05639  0.00574 -0.35252
-H  0.02576  0.02013 0.35149
-
-2 
-
-H -0.05573  0.00663 -0.35406
-H  0.02638  0.02036 0.35312
-
-2 
-
-H -0.05518  0.00737 -0.35560
-H  0.02704  0.02059 0.35472
-
-2 
-
-H -0.05473  0.00802 -0.35712
-H  0.02772  0.02080 0.35631
-
-2 
-
-H -0.05440  0.00858 -0.35863
-H  0.02839  0.02100 0.35786
-
-2 
-
-H -0.05417  0.00889 -0.36012
-H  0.02906  0.02119 0.35940
-
-2 
-
-H -0.05402  0.00906 -0.36158
-H  0.02973  0.02136 0.36090
-
-2 
-
-H -0.05394  0.00921 -0.36302
-H  0.03042  0.02153 0.36238
-
-2 
-
-H -0.05392  0.00928 -0.36444
-H  0.03110  0.02166 0.36385
-
-2 
-
-H -0.05392  0.00929 -0.36584
-H  0.03171  0.02176 0.36529
-
-2 
-
-H -0.05397  0.00930 -0.36723
-H  0.03232  0.02188 0.36672
-

From 9b601d13d6a0bf094cef053a95b2080c0e5d2da2 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:54:20 +0100
Subject: [PATCH 142/286] chagne nbexecute to never

---
 docs/conf.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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

From 07e14421497317f99d8cf537435aafaf4bf5fb3a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:54:54 +0100
Subject: [PATCH 143/286] added jupyter as dep

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 06835d92..dfc4f30b 100644
--- a/setup.py
+++ b/setup.py
@@ -48,7 +48,7 @@
 
     extras_require={
         'hpc': ['horovod==0.27.0'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert'],
+        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert','jupyter'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],
     }

From fab56a9301e4ad14ce1e97c490f2b0527b5d157d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:55:39 +0100
Subject: [PATCH 144/286] introduce default jastrow as elec-elec pade jastrow

---
 qmctorch/scf/molecule.py  | 2 +-
 qmctorch/solver/solver.py | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 85a027fb..f3b51900 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -41,7 +41,7 @@ def __init__(  # pylint: disable=too-many-arguments
             calculator (str, optional): selet scf calculator. Defaults to 'adf'.
                 - pyscf : PySCF calculator
                 - adf : ADF2020+ calculator
-                - adf2019 : ADF2019 calculatori
+                - adf2019 : ADF2019 calculator
             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
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 3cda3f07..bda0cf8d 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -106,8 +106,9 @@ 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 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

From e3900c9a1d548a49e812f1480850846cbe860cf6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 11:56:38 +0100
Subject: [PATCH 145/286] default jastrow

---
 qmctorch/wavefunction/slater_jastrow.py | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index a3d0ec5c..94e6a30a 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -9,6 +9,8 @@
 from .. import log
 
 from .wf_base import WaveFunction
+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.atomic_orbitals_backflow import AtomicOrbitalsBackFlow
@@ -21,7 +23,7 @@ class SlaterJastrow(WaveFunction):
     def __init__(
         self,
         mol,
-        jastrow=None,
+        jastrow='default',
         backflow=None,
         configs="ground_state",
         kinetic="jacobi",
@@ -42,8 +44,8 @@ def __init__(
 
         Args:
             mol (Molecule): a QMCTorch molecule object
-            jastrow_kernel (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            backflow_kernel (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            jastrow (JastrowKernelBase, optional) : Class that computes the jastrow kernels
+            backflow (BackFlowKernelBase, optional) : kernel function of the backflow transformation
             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
@@ -181,18 +183,28 @@ def init_fc_layer(self):
     def init_jastrow(self, jastrow):
         """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
 
-            if isinstance(jastrow, list):
+            # create a simple Pade Jastrow factor as default
+            if jastrow == 'default':
+                self.jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
+
+            elif isinstance(jastrow, list):
                 self.jastrow = CombineJastrow(jastrow)
-            else:
+
+            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)

From 13ae24d116b872e9a1c439cedca07a9e384b3932 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 12:16:58 +0100
Subject: [PATCH 146/286] fix build file

---
 .github/workflows/build.yml | 31 -------------------------------
 1 file changed, 31 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ae3ae99a..9402c20f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -61,17 +61,6 @@ jobs:
         GITHUB_TOKEN: ${{ secrets.github_token }}
         COVERALLS_FLAG_NAME: python-${{ matrix.version }}
         COVERALLS_PARALLEL: true
-    # Standard drop-in approach that should work for most people.
-    - uses: ammaraskar/sphinx-action@master
-      with:
-        docs-folder: "docs/"
-    # Great extra actions to compose with:
-    # Create an artifact of the html output.
-    - uses: actions/upload-artifact@v1
-      with:
-        name: DocumentationHTML
-        path: docs/_build/html/
-    
 
   finish:
     needs: build
@@ -82,23 +71,3 @@ jobs:
         with:
           github-token: ${{ secrets.github_token }}
           parallel-finished: true
-      # Publish built docs to gh-pages branch.
-      # ===============================
-      - name: Commit documentation changes
-        run: |
-          git clone https://github.com/NLESC-JCER/QMCTorch.git --branch gh-pages --single-branch gh-pages
-          cp -r docs/_build/html/* gh-pages/
-          cd gh-pages
-          touch .nojekyll
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          git add .
-          git commit -m "Update documentation" -a || true
-          # The above command will fail if no changes were present, so we ignore
-          # that.
-      - name: Push changes
-        uses: ad-m/github-push-action@master
-        with:
-          branch: gh-pages
-          directory: gh-pages
-          github_token: ${{ secrets.GITHUB_TOKEN }}

From cc397de88cbc40f5f8d86501d435ab72379551e1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 14:12:41 +0100
Subject: [PATCH 147/286] updated rst in the doc

---
 docs/rst/qmctorch.rst | 269 ++++++++++++++++++++++++------------------
 1 file changed, 155 insertions(+), 114 deletions(-)

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

From 6ebdd88954571578d61913f20aaee5ba079884b9 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 14:27:18 +0100
Subject: [PATCH 148/286] fix some docstrings

---
 .../elec_elec_nuclei/kernels/boys_handy_jastrow_kernel.py   | 2 +-
 qmctorch/wavefunction/slater_jastrow.py                     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

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 eae30937..0ec75e3f 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
@@ -9,7 +9,7 @@ class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
     def __init__(
         self, nup, ndown, atomic_pos, cuda, nterm=5
     ):  # pylint: disable=too-many-arguments
-        """Defines a Boys Handy jastrow factors.
+        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
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 94e6a30a..6f919e2f 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -341,7 +341,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
 
@@ -453,11 +453,11 @@ def get_kinetic_operator(self, x, ao, dao, d2ao, mo):
         return -0.5 * bkin
 
     def kinetic_energy_jacobi_backflow(self, x, **kwargs):
-        r"""Compute the value of the kinetic enery using the Jacobi Formula.
+        """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
         .. math::
-             \\frac{\Delta (J(R) \Psi(R))}{ J(R) \Psi(R)} = \\frac{\\Delta J(R)}{J(R}
+             \\frac{\\Delta (J(R) \\Psi(R))}{ J(R) \\Psi(R)} = \\frac{\\Delta J(R)}{J(R}
                                                           + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)}
                                                           + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}
 

From 7b9e0266f6aa5267f773f44e479f47cb6496bd5d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 5 Dec 2023 14:38:46 +0100
Subject: [PATCH 149/286] fix foc

---
 docs/source/modules.rst | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

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

From a378c00c7b47545f54af819b41049872b56efbf5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Sat, 9 Dec 2023 12:01:52 +0100
Subject: [PATCH 150/286] fix factorial2

---
 docs/example/single_point/h2.py                |  2 +-
 qmctorch/wavefunction/orbitals/norm_orbital.py | 18 +++++++++++++-----
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
index 27017364..3a1c603c 100644
--- a/docs/example/single_point/h2.py
+++ b/docs/example/single_point/h2.py
@@ -15,7 +15,7 @@
 
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
-                   configs='ground_state', jastrow=jastrow).gto2sto()
+                   configs='ground_state', jastrow=jastrow) #.gto2sto()
 
 # sampler
 sampler = Metropolis(nwalkers=1000, nstep=1000, step_size=0.25,
diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 8b7d5546..d8b346ea 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -1,6 +1,6 @@
 import torch
 import numpy as np
-
+from scipy.special import factorial2
 
 def atomic_orbital_norm(basis):
     """Computes the norm of the atomic orbitals
@@ -141,16 +141,24 @@ def norm_gaussian_cartesian(a, b, c, exp):
         torch.tensor: normalization factor
     """
 
-    from scipy.special import factorial2 as f2
-
     pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
     am1 = (2 * a - 1).astype("int")
     x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(f2(am1)))
 
     bm1 = (2 * b - 1).astype("int")
     y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(f2(bm1)))
-
+    
     cm1 = (2 * c - 1).astype("int")
-    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(f2(cm1)))
+    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(f2(cm1))) 
 
     return (pref * x * y * z).type(torch.get_default_dtype())
+
+def f2(x):
+    """Returns the f2 of x with f2(x<1) = 1 as implemented in scipy 1.10.
+    """
+    # compute the x!!
+    out = factorial2(x)
+
+    # set all the elements lower than 1 to 1 
+    out[out<1] = 1
+    return out
\ No newline at end of file

From 45f57ac737cfa9358f7bea920c28eb0a751f9f2b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Sat, 9 Dec 2023 12:03:11 +0100
Subject: [PATCH 151/286] added 3.9 python in CI

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9402c20f..767cd31b 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: [3.8]
+        version: [3.8,3.9]
 
     steps:
     - name: Cancel Previous Runs

From c85c62bbd50683575ca5a86249eae28a0a9af850 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Sat, 9 Dec 2023 12:30:54 +0100
Subject: [PATCH 152/286] froze scipy

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index dfc4f30b..1c3fdd39 100644
--- a/setup.py
+++ b/setup.py
@@ -41,7 +41,7 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
+                      'scipy==1.10.1', 'tqdm', 'torch', 'dgl', 'dgllife',
                       'plams', 'pints',
                       'pyscf', 'mendeleev', 'twiggy',
                       'plams', 'mpi4py'],

From 53ff7e626f7801689b59795b2deeb3ef6373da85 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Sat, 9 Dec 2023 13:25:36 +0100
Subject: [PATCH 153/286] fix 2

---
 qmctorch/wavefunction/orbitals/norm_orbital.py | 2 --
 setup.py                                       | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index d8b346ea..fd73b567 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -75,7 +75,6 @@ def norm_gaussian_spherical(bas_n, bas_exp):
         torch.tensor: normalization factor
     """
 
-    from scipy.special import factorial2 as f2
 
     bas_n = torch.tensor(bas_n)
     bas_n = bas_n + 1.0
@@ -104,7 +103,6 @@ def norm_slater_cartesian(a, b, c, n, exp):
     Returns:
         torch.tensor: normalization factor
     """
-    from scipy.special import factorial2 as f2
 
     lvals = a + b + c + n + 1.0
 
diff --git a/setup.py b/setup.py
index 1c3fdd39..dfc4f30b 100644
--- a/setup.py
+++ b/setup.py
@@ -41,7 +41,7 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy==1.10.1', 'tqdm', 'torch', 'dgl', 'dgllife',
+                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
                       'plams', 'pints',
                       'pyscf', 'mendeleev', 'twiggy',
                       'plams', 'mpi4py'],

From bc5010037a4146b960d5903ff86a025bda59bff6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 11 Dec 2023 16:02:24 +0100
Subject: [PATCH 154/286] fux default jastrow on gpu

---
 qmctorch/wavefunction/slater_jastrow.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 6f919e2f..edde7ae7 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -194,7 +194,9 @@ def init_jastrow(self, jastrow):
 
             # create a simple Pade Jastrow factor as default
             if jastrow == 'default':
-                self.jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
+                self.jastrow = JastrowFactorElectronElectron(self.mol, 
+                                                             PadeJastrowKernel, 
+                                                             cuda=self.cuda)
 
             elif isinstance(jastrow, list):
                 self.jastrow = CombineJastrow(jastrow)

From 46e191b9f098c6548239cc1fd06cfec0125935d7 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 12 Dec 2023 21:09:16 +0100
Subject: [PATCH 155/286] removed graph jastrow

---
 .../wavefunction/jastrows/graph/__init__.py   |   4 -
 .../jastrows/graph/elec_elec_graph.py         |  45 ---
 .../jastrows/graph/elec_nuc_graph.py          |  83 -----
 .../jastrows/graph/jastrow_graph.py           | 265 ---------------
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 315 ------------------
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  97 ------
 7 files changed, 809 deletions(-)
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py

diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
deleted file mode 100644
index af55bd1c..00000000
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from .jastrow_graph import JastrowFactorGraph as JastrowFactor
-from .mgcn.mgcn_predictor import MGCNPredictor
-
-__all__ = ["JastrowFactor", "MGCNPredictor"]
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
deleted file mode 100644
index 35a8f7f9..00000000
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import dgl
-import torch
-
-
-def ElecElecGraph(nelec, nup):
-    """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):
-    """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, nup):
-    """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
deleted file mode 100644
index 0cb22dc8..00000000
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import dgl
-import torch
-from mendeleev import element
-
-
-def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
-    """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, nelec):
-    """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, atom_types, atomic_features, nelec, nup):
-    """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, atomic_features):
-    """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/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
deleted file mode 100644
index a2c409c1..00000000
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ /dev/null
@@ -1,265 +0,0 @@
-import torch
-from torch import nn
-from torch.autograd import grad
-import dgl
-
-from .mgcn.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
-
-
-class JastrowFactorGraph(nn.Module):
-    def __init__(
-        self,
-        mol,
-        ee_model=MGCNPredictor,
-        ee_model_kwargs={},
-        en_model=MGCNPredictor,
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-    ):
-        """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 = ee_model(**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 = en_model(**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 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) 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, en_kernel):
-        """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, ee_kernel, en_kernel, sum_grad):
-        """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, ee_kernel, en_kernel, sum_grad=False, return_all=False
-    ):
-        """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):
-        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):
-        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):
-        """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/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
deleted file mode 100644
index 4b69b18e..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import dgl.function as fn
-import torch
-import torch.nn as nn
-
-from dgllife.model.gnn.schnet import RBFExpansion
-
-
-class EdgeEmbedding(nn.Module):
-    """Module for embedding edges.
-
-    Edges whose end nodes have the same combination of types
-    share the same initial embedding.
-
-    Parameters
-    ----------
-    num_types : int
-        Number of edge types to embed.
-    edge_feats : int
-        Size for the edge representations to learn.
-    """
-
-    def __init__(self, num_types, edge_feats):
-        super(EdgeEmbedding, self).__init__()
-        self.embed = nn.Embedding(num_types, edge_feats)
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.embed.reset_parameters()
-
-    def get_edge_types(self, edges):
-        """Generates edge types.
-
-        The edge type is based on the type of the source and destination nodes.
-        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
-
-        To map each pair of node types to a unique number, we use an unordered pairing function.
-        See more details in this discussion:
-        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
-        Note that the number of edge types should be larger than the square of the maximum node
-        type in the dataset.
-
-        Parameters
-        ----------
-        edges : EdgeBatch
-            Container for a batch of edges.
-
-        Returns
-        -------
-        dict
-            Mapping 'type' to the computed edge types.
-        """
-        node_type1 = edges.src["type"]
-        node_type2 = edges.dst["type"]
-        return {
-            "type": node_type1 * node_type2
-            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
-        }
-
-    def forward(self, g, node_types):
-        """Embeds edge types.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-
-        Returns
-        -------
-        float32 tensor of shape (E, edge_feats)
-            Edge representations.
-        """
-        g = g.local_var()
-        g.ndata["type"] = node_types
-        g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata["type"])
-
-
-class VEConv(nn.Module):
-    """Vertex-Edge Convolution in MGCN
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This layer combines both node and edge features in updating node representations.
-
-    Parameters
-    ----------
-    dist_feats : int
-        Size for the expanded distances.
-    feats : int
-        Size for the input and output node and edge representations.
-    update_edge : bool
-        Whether to update edge representations. Default to True.
-    """
-
-    def __init__(self, dist_feats, feats, update_edge=True):
-        super(VEConv, self).__init__()
-
-        self.update_dists = nn.Sequential(
-            nn.Linear(dist_feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        if update_edge:
-            self.update_edge_feats = nn.Linear(feats, feats)
-        else:
-            self.update_edge_feats = None
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        for layer in self.update_dists:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-
-        if self.update_edge_feats is not None:
-            self.update_edge_feats.reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features.
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Edge representations, updated if ``update_edge == True`` in initialization.
-        """
-        expanded_dists = self.update_dists(expanded_dists)
-        if self.update_edge_feats is not None:
-            edge_feats = self.update_edge_feats(edge_feats)
-
-        g = g.local_var()
-        g.ndata.update({"hv": node_feats})
-        g.edata.update({"dist": expanded_dists, "he": edge_feats})
-        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
-        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
-        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
-
-        return node_feats, edge_feats
-
-
-class MultiLevelInteraction(nn.Module):
-    """Building block for MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
-    edge features and expanded distances in message passing and updates node and edge
-    representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the input and output node and edge representations.
-    dist_feats : int
-        Size for the expanded distances.
-    """
-
-    def __init__(self, feats, dist_feats):
-        super(MultiLevelInteraction, self).__init__()
-
-        self.project_in_node_feats = nn.Linear(feats, feats)
-        self.conv = VEConv(dist_feats, feats)
-        self.project_out_node_feats = nn.Sequential(
-            nn.Linear(feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
-        )
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.project_in_node_feats.reset_parameters()
-        self.conv.reset_parameters()
-        for layer in self.project_out_node_feats:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-        self.project_edge_feats[0].reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Updated edge representations.
-        """
-        new_node_feats = self.project_in_node_feats(node_feats)
-        new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists
-        )
-        new_node_feats = self.project_out_node_feats(new_node_feats)
-        node_feats = node_feats + new_node_feats
-
-        edge_feats = self.project_edge_feats(edge_feats)
-
-        return node_feats, edge_feats
-
-
-class MGCNGNN(nn.Module):
-    """MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This class performs message passing in MGCN and returns the updated node representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 30.
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 0.1.
-    """
-
-    def __init__(  # pylint: disable=to-many-arguments
-        self,
-        feats=128,
-        n_layers=3,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=30.0,
-        gap=0.1,
-    ):
-        super(MGCNGNN, self).__init__()
-
-        self.node_embed = nn.Embedding(num_node_types, feats)
-        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
-        self.high = cutoff
-        self.gap = gap
-        self.rbf = RBFExpansion(high=cutoff, gap=gap)
-
-        self.gnn_layers = nn.ModuleList()
-        for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.node_embed.reset_parameters()
-        self.edge_embed.reset_parameters()
-        self.rbf.reset_parameters()
-
-        for layer in self.gnn_layers:
-            layer.reset_parameters()
-
-    def forward(self, g, node_types, edge_dists):
-        """Performs message passing and updates node representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (V, feats * (n_layers + 1))
-            Output node representations.
-        """
-
-        node_feats = self.node_embed(node_types)
-        edge_feats = self.edge_embed(g, node_types)
-        expanded_dists = self.rbf(edge_dists)
-
-        all_layer_node_feats = [node_feats]
-        for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
-            all_layer_node_feats.append(node_feats)
-        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
deleted file mode 100644
index 9f710fd3..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import torch.nn as nn
-from dgllife.model.readout import MLPNodeReadout
-from .mgcn import MGCNGNN
-
-
-class MGCNPredictor(nn.Module):
-    """MGCN for for regression and classification on graphs.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    classifier_hidden_feats : int
-        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
-        representations in the classifier. Default to 64.
-    n_tasks : int
-        Number of tasks, which is also the output size. Default to 1.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 5.0
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 1.0
-    predictor_hidden_feats : int
-        Size for hidden representations in the output MLP predictor. Default to 64.
-    """
-
-    def __init__(
-        self,
-        feats=128,
-        n_layers=3,
-        classifier_hidden_feats=64,
-        n_tasks=1,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=5.0,
-        gap=1.0,
-        predictor_hidden_feats=64,
-    ):
-        super(MGCNPredictor, self).__init__()
-
-        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print(
-                "classifier_hidden_feats is deprecated and will be removed in the future, "
-                "use predictor_hidden_feats instead"
-            )
-            predictor_hidden_feats = classifier_hidden_feats
-
-        self.gnn = MGCNGNN(
-            feats=feats,
-            n_layers=n_layers,
-            num_node_types=num_node_types,
-            num_edge_types=num_edge_types,
-            cutoff=cutoff,
-            gap=gap,
-        )
-        self.readout = MLPNodeReadout(
-            node_feats=(n_layers + 1) * feats,
-            hidden_feats=predictor_hidden_feats,
-            graph_feats=n_tasks,
-            activation=nn.Softplus(beta=1, threshold=20),
-        )
-
-    def forward(self, g, node_types, edge_dists):
-        """Graph-level regression/soft classification.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (G, n_tasks)
-            Prediction for the graphs in the batch. G for the number of graphs.
-        """
-        node_feats = self.gnn(g, node_types, edge_dists)
-        return self.readout(g, node_feats)

From 44648fab55ead3036051efc68d3f6e13cdffe746 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 12 Dec 2023 21:10:47 +0100
Subject: [PATCH 156/286] removed graph jastrow test

---
 tests/wavefunction/jastrows/graph/__init__.py |   0
 .../jastrows/graph/test_graph_jastrow.py      | 114 ------------
 .../test_slater_mgcn_graph_jastrow.py         | 176 ------------------
 3 files changed, 290 deletions(-)
 delete mode 100644 tests/wavefunction/jastrows/graph/__init__.py
 delete mode 100644 tests/wavefunction/jastrows/graph/test_graph_jastrow.py
 delete mode 100644 tests/wavefunction/test_slater_mgcn_graph_jastrow.py

diff --git a/tests/wavefunction/jastrows/graph/__init__.py b/tests/wavefunction/jastrows/graph/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
deleted file mode 100644
index 67ac08ab..00000000
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import unittest
-import numpy as np
-import torch
-from torch.autograd import Variable, grad
-from types import SimpleNamespace
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
-from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
-
-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 = JastrowFactorGraph(
-            self.mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            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/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
deleted file mode 100644
index 11ca4c4c..00000000
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ /dev/null
@@ -1,176 +0,0 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.graph import JastrowFactor, MGCNPredictor
-
-from torch.autograd import grad, gradcheck, Variable
-
-import numpy as np
-import torch
-import unittest
-
-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 TestSlaterJastrowGraph(unittest.TestCase):
-    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 = JastrowFactor(
-            mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-        )
-        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.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()

From 926a51e0eaab4229142a030f835509d49800a45f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 12 Dec 2023 21:13:50 +0100
Subject: [PATCH 157/286] Revert "removed graph jastrow test"

This reverts commit 44648fab55ead3036051efc68d3f6e13cdffe746.
---
 tests/wavefunction/jastrows/graph/__init__.py |   0
 .../jastrows/graph/test_graph_jastrow.py      | 114 ++++++++++++
 .../test_slater_mgcn_graph_jastrow.py         | 176 ++++++++++++++++++
 3 files changed, 290 insertions(+)
 create mode 100644 tests/wavefunction/jastrows/graph/__init__.py
 create mode 100644 tests/wavefunction/jastrows/graph/test_graph_jastrow.py
 create mode 100644 tests/wavefunction/test_slater_mgcn_graph_jastrow.py

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..67ac08ab
--- /dev/null
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -0,0 +1,114 @@
+import unittest
+import numpy as np
+import torch
+from torch.autograd import Variable, grad
+from types import SimpleNamespace
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+
+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 = JastrowFactorGraph(
+            self.mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            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/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
new file mode 100644
index 00000000..11ca4c4c
--- /dev/null
+++ b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
@@ -0,0 +1,176 @@
+from qmctorch.scf import Molecule
+from qmctorch.wavefunction import SlaterJastrow
+from qmctorch.utils import set_torch_double_precision
+from qmctorch.wavefunction.jastrows.graph import JastrowFactor, MGCNPredictor
+
+from torch.autograd import grad, gradcheck, Variable
+
+import numpy as np
+import torch
+import unittest
+
+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 TestSlaterJastrowGraph(unittest.TestCase):
+    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 = JastrowFactor(
+            mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+        )
+        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.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()

From 43f466b74c5b00a3b8cc0f638e1a1286c16313ce Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 12 Dec 2023 21:14:11 +0100
Subject: [PATCH 158/286] Revert "removed graph jastrow"

This reverts commit 46e191b9f098c6548239cc1fd06cfec0125935d7.
---
 .../wavefunction/jastrows/graph/__init__.py   |   4 +
 .../jastrows/graph/elec_elec_graph.py         |  45 +++
 .../jastrows/graph/elec_nuc_graph.py          |  83 +++++
 .../jastrows/graph/jastrow_graph.py           | 265 +++++++++++++++
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 315 ++++++++++++++++++
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  97 ++++++
 7 files changed, 809 insertions(+)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py

diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
new file mode 100644
index 00000000..af55bd1c
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -0,0 +1,4 @@
+from .jastrow_graph import JastrowFactorGraph as JastrowFactor
+from .mgcn.mgcn_predictor import MGCNPredictor
+
+__all__ = ["JastrowFactor", "MGCNPredictor"]
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..35a8f7f9
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -0,0 +1,45 @@
+import dgl
+import torch
+
+
+def ElecElecGraph(nelec, nup):
+    """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):
+    """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, nup):
+    """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..0cb22dc8
--- /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, atom_types, atomic_features, nelec, nup):
+    """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, nelec):
+    """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, atom_types, atomic_features, nelec, nup):
+    """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, atomic_features):
+    """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/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
new file mode 100644
index 00000000..a2c409c1
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -0,0 +1,265 @@
+import torch
+from torch import nn
+from torch.autograd import grad
+import dgl
+
+from .mgcn.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
+
+
+class JastrowFactorGraph(nn.Module):
+    def __init__(
+        self,
+        mol,
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+    ):
+        """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 = ee_model(**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 = en_model(**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 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) 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, en_kernel):
+        """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, ee_kernel, en_kernel, sum_grad):
+        """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, ee_kernel, en_kernel, sum_grad=False, return_all=False
+    ):
+        """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):
+        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):
+        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):
+        """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/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
new file mode 100644
index 00000000..4b69b18e
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import dgl.function as fn
+import torch
+import torch.nn as nn
+
+from dgllife.model.gnn.schnet import RBFExpansion
+
+
+class EdgeEmbedding(nn.Module):
+    """Module for embedding edges.
+
+    Edges whose end nodes have the same combination of types
+    share the same initial embedding.
+
+    Parameters
+    ----------
+    num_types : int
+        Number of edge types to embed.
+    edge_feats : int
+        Size for the edge representations to learn.
+    """
+
+    def __init__(self, num_types, edge_feats):
+        super(EdgeEmbedding, self).__init__()
+        self.embed = nn.Embedding(num_types, edge_feats)
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.embed.reset_parameters()
+
+    def get_edge_types(self, edges):
+        """Generates edge types.
+
+        The edge type is based on the type of the source and destination nodes.
+        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
+
+        To map each pair of node types to a unique number, we use an unordered pairing function.
+        See more details in this discussion:
+        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
+        Note that the number of edge types should be larger than the square of the maximum node
+        type in the dataset.
+
+        Parameters
+        ----------
+        edges : EdgeBatch
+            Container for a batch of edges.
+
+        Returns
+        -------
+        dict
+            Mapping 'type' to the computed edge types.
+        """
+        node_type1 = edges.src["type"]
+        node_type2 = edges.dst["type"]
+        return {
+            "type": node_type1 * node_type2
+            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+        }
+
+    def forward(self, g, node_types):
+        """Embeds edge types.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+
+        Returns
+        -------
+        float32 tensor of shape (E, edge_feats)
+            Edge representations.
+        """
+        g = g.local_var()
+        g.ndata["type"] = node_types
+        g.apply_edges(self.get_edge_types)
+        return self.embed(g.edata["type"])
+
+
+class VEConv(nn.Module):
+    """Vertex-Edge Convolution in MGCN
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This layer combines both node and edge features in updating node representations.
+
+    Parameters
+    ----------
+    dist_feats : int
+        Size for the expanded distances.
+    feats : int
+        Size for the input and output node and edge representations.
+    update_edge : bool
+        Whether to update edge representations. Default to True.
+    """
+
+    def __init__(self, dist_feats, feats, update_edge=True):
+        super(VEConv, self).__init__()
+
+        self.update_dists = nn.Sequential(
+            nn.Linear(dist_feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats),
+        )
+        if update_edge:
+            self.update_edge_feats = nn.Linear(feats, feats)
+        else:
+            self.update_edge_feats = None
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        for layer in self.update_dists:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+
+        if self.update_edge_feats is not None:
+            self.update_edge_feats.reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features.
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Edge representations, updated if ``update_edge == True`` in initialization.
+        """
+        expanded_dists = self.update_dists(expanded_dists)
+        if self.update_edge_feats is not None:
+            edge_feats = self.update_edge_feats(edge_feats)
+
+        g = g.local_var()
+        g.ndata.update({"hv": node_feats})
+        g.edata.update({"dist": expanded_dists, "he": edge_feats})
+        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
+        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
+        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
+
+        return node_feats, edge_feats
+
+
+class MultiLevelInteraction(nn.Module):
+    """Building block for MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
+    edge features and expanded distances in message passing and updates node and edge
+    representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the input and output node and edge representations.
+    dist_feats : int
+        Size for the expanded distances.
+    """
+
+    def __init__(self, feats, dist_feats):
+        super(MultiLevelInteraction, self).__init__()
+
+        self.project_in_node_feats = nn.Linear(feats, feats)
+        self.conv = VEConv(dist_feats, feats)
+        self.project_out_node_feats = nn.Sequential(
+            nn.Linear(feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats),
+        )
+        self.project_edge_feats = nn.Sequential(
+            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
+        )
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.project_in_node_feats.reset_parameters()
+        self.conv.reset_parameters()
+        for layer in self.project_out_node_feats:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+        self.project_edge_feats[0].reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Updated edge representations.
+        """
+        new_node_feats = self.project_in_node_feats(node_feats)
+        new_node_feats, edge_feats = self.conv(
+            g, new_node_feats, edge_feats, expanded_dists
+        )
+        new_node_feats = self.project_out_node_feats(new_node_feats)
+        node_feats = node_feats + new_node_feats
+
+        edge_feats = self.project_edge_feats(edge_feats)
+
+        return node_feats, edge_feats
+
+
+class MGCNGNN(nn.Module):
+    """MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This class performs message passing in MGCN and returns the updated node representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 30.
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 0.1.
+    """
+
+    def __init__(  # pylint: disable=to-many-arguments
+        self,
+        feats=128,
+        n_layers=3,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=30.0,
+        gap=0.1,
+    ):
+        super(MGCNGNN, self).__init__()
+
+        self.node_embed = nn.Embedding(num_node_types, feats)
+        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
+        self.high = cutoff
+        self.gap = gap
+        self.rbf = RBFExpansion(high=cutoff, gap=gap)
+
+        self.gnn_layers = nn.ModuleList()
+        for _ in range(n_layers):
+            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.node_embed.reset_parameters()
+        self.edge_embed.reset_parameters()
+        self.rbf.reset_parameters()
+
+        for layer in self.gnn_layers:
+            layer.reset_parameters()
+
+    def forward(self, g, node_types, edge_dists):
+        """Performs message passing and updates node representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (V, feats * (n_layers + 1))
+            Output node representations.
+        """
+
+        node_feats = self.node_embed(node_types)
+        edge_feats = self.edge_embed(g, node_types)
+        expanded_dists = self.rbf(edge_dists)
+
+        all_layer_node_feats = [node_feats]
+        for gnn in self.gnn_layers:
+            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
+            all_layer_node_feats.append(node_feats)
+        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
new file mode 100644
index 00000000..9f710fd3
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import torch.nn as nn
+from dgllife.model.readout import MLPNodeReadout
+from .mgcn import MGCNGNN
+
+
+class MGCNPredictor(nn.Module):
+    """MGCN for for regression and classification on graphs.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    classifier_hidden_feats : int
+        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
+        representations in the classifier. Default to 64.
+    n_tasks : int
+        Number of tasks, which is also the output size. Default to 1.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 5.0
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 1.0
+    predictor_hidden_feats : int
+        Size for hidden representations in the output MLP predictor. Default to 64.
+    """
+
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        classifier_hidden_feats=64,
+        n_tasks=1,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=5.0,
+        gap=1.0,
+        predictor_hidden_feats=64,
+    ):
+        super(MGCNPredictor, self).__init__()
+
+        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
+            print(
+                "classifier_hidden_feats is deprecated and will be removed in the future, "
+                "use predictor_hidden_feats instead"
+            )
+            predictor_hidden_feats = classifier_hidden_feats
+
+        self.gnn = MGCNGNN(
+            feats=feats,
+            n_layers=n_layers,
+            num_node_types=num_node_types,
+            num_edge_types=num_edge_types,
+            cutoff=cutoff,
+            gap=gap,
+        )
+        self.readout = MLPNodeReadout(
+            node_feats=(n_layers + 1) * feats,
+            hidden_feats=predictor_hidden_feats,
+            graph_feats=n_tasks,
+            activation=nn.Softplus(beta=1, threshold=20),
+        )
+
+    def forward(self, g, node_types, edge_dists):
+        """Graph-level regression/soft classification.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (G, n_tasks)
+            Prediction for the graphs in the batch. G for the number of graphs.
+        """
+        node_feats = self.gnn(g, node_types, edge_dists)
+        return self.readout(g, node_feats)

From af66f836288fb5ea50f80e645f74932ce994e181 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 4 Dec 2024 15:32:01 +0100
Subject: [PATCH 159/286] fix egnn

---
 .../jastrows/graph/egnn/__init__.py           |   0
 .../wavefunction/jastrows/graph/egnn/egnn.py  |  88 +++++
 .../wavefunction/jastrows/graph/egnn/gcl.py   | 351 ++++++++++++++++++
 3 files changed, 439 insertions(+)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/gcl.py

diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py b/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
new file mode 100644
index 00000000..47e18648
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
@@ -0,0 +1,88 @@
+from models.gcl import E_GCL, unsorted_segment_sum
+import torch
+from torch import nn
+
+
+class E_GCL_mask(E_GCL):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_attr_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False):
+        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_attr_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention)
+
+        del self.coord_mlp
+        self.act_fn = act_fn
+
+    def coord_model(self, coord, edge_index, coord_diff, edge_feat, edge_mask):
+        row, col = edge_index
+        trans = coord_diff * self.coord_mlp(edge_feat) * edge_mask
+        agg = unsorted_segment_sum(trans, row, num_segments=coord.size(0))
+        coord += agg*self.coords_weight
+        return coord
+
+    def forward(self, h, edge_index, coord, node_mask, edge_mask, edge_attr=None, node_attr=None, n_nodes=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+
+        edge_feat = edge_feat * edge_mask
+
+        # TO DO: edge_feat = edge_feat * edge_mask
+
+        #coord = self.coord_model(coord, edge_index, coord_diff, edge_feat, edge_mask)
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+
+        return h, coord, edge_attr
+
+
+
+class EGNN(nn.Module):
+    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, device='cpu', act_fn=nn.SiLU(), n_layers=4, coords_weight=1.0, attention=False, node_attr=1):
+        super(EGNN, self).__init__()
+        self.hidden_nf = hidden_nf
+        self.device = device
+        self.n_layers = n_layers
+
+        ### Encoder
+        self.embedding = nn.Linear(in_node_nf, hidden_nf)
+        self.node_attr = node_attr
+        if node_attr:
+            n_node_attr = in_node_nf
+        else:
+            n_node_attr = 0
+        for i in range(0, n_layers):
+            self.add_module("gcl_%d" % i, E_GCL_mask(self.hidden_nf, self.hidden_nf, self.hidden_nf, edges_in_d=in_edge_nf, nodes_attr_dim=n_node_attr, act_fn=act_fn, recurrent=True, coords_weight=coords_weight, attention=attention))
+
+        self.node_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
+                                      act_fn,
+                                      nn.Linear(self.hidden_nf, self.hidden_nf))
+
+        self.graph_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
+                                       act_fn,
+                                       nn.Linear(self.hidden_nf, 1))
+        self.to(self.device)
+
+    def forward(self, h0, x, edges, edge_attr, node_mask, edge_mask, n_nodes):
+        h = self.embedding(h0)
+        for i in range(0, self.n_layers):
+            if self.node_attr:
+                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr, node_attr=h0, n_nodes=n_nodes)
+            else:
+                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr,
+                                                      node_attr=None, n_nodes=n_nodes)
+
+        h = self.node_dec(h)
+        h = h * node_mask
+        h = h.view(-1, n_nodes, self.hidden_nf)
+        h = torch.sum(h, dim=1)
+        pred = self.graph_dec(h)
+        return pred.squeeze(1)
+
+
+
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
new file mode 100644
index 00000000..3d1aebfd
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
@@ -0,0 +1,351 @@
+from torch import nn
+import torch
+
+class MLP(nn.Module):
+    """ a simple 4-layer MLP """
+
+    def __init__(self, nin, nout, nh):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(nin, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nout),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class GCL_basic(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self):
+        super(GCL_basic, self).__init__()
+
+
+    def edge_model(self, source, target, edge_attr):
+        pass
+
+    def node_model(self, h, edge_index, edge_attr):
+        pass
+
+    def forward(self, x, edge_index, edge_attr=None):
+        row, col = edge_index
+        edge_feat = self.edge_model(x[row], x[col], edge_attr)
+        x = self.node_model(x, edge_index, edge_feat)
+        return x, edge_feat
+
+
+
+class GCL(GCL_basic):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_nf=0, act_fn=nn.ReLU(), bias=True, attention=False, t_eq=False, recurrent=True):
+        super(GCL, self).__init__()
+        self.attention = attention
+        self.t_eq=t_eq
+        self.recurrent = recurrent
+        input_edge_nf = input_nf * 2
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(input_edge_nf + edges_in_nf, hidden_nf, bias=bias),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf, bias=bias),
+            act_fn)
+        if self.attention:
+            self.att_mlp = nn.Sequential(
+                nn.Linear(input_nf, hidden_nf, bias=bias),
+                act_fn,
+                nn.Linear(hidden_nf, 1, bias=bias),
+                nn.Sigmoid())
+
+
+        self.node_mlp = nn.Sequential(
+            nn.Linear(hidden_nf + input_nf, hidden_nf, bias=bias),
+            act_fn,
+            nn.Linear(hidden_nf, output_nf, bias=bias))
+
+        #if recurrent:
+            #self.gru = nn.GRUCell(hidden_nf, hidden_nf)
+
+
+    def edge_model(self, source, target, edge_attr):
+        edge_in = torch.cat([source, target], dim=1)
+        if edge_attr is not None:
+            edge_in = torch.cat([edge_in, edge_attr], dim=1)
+        out = self.edge_mlp(edge_in)
+        if self.attention:
+            att = self.att_mlp(torch.abs(source - target))
+            out = out * att
+        return out
+
+    def node_model(self, h, edge_index, edge_attr):
+        row, col = edge_index
+        agg = unsorted_segment_sum(edge_attr, row, num_segments=h.size(0))
+        out = torch.cat([h, agg], dim=1)
+        out = self.node_mlp(out)
+        if self.recurrent:
+            out = out + h
+            #out = self.gru(out, h)
+        return out
+
+
+class GCL_rf(GCL_basic):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, nf=64, edge_attr_nf=0, reg=0, act_fn=nn.LeakyReLU(0.2), clamp=False):
+        super(GCL_rf, self).__init__()
+
+        self.clamp = clamp
+        layer = nn.Linear(nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+        self.phi = nn.Sequential(nn.Linear(edge_attr_nf + 1, nf),
+                                 act_fn,
+                                 layer)
+        self.reg = reg
+
+    def edge_model(self, source, target, edge_attr):
+        x_diff = source - target
+        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
+        e_input = torch.cat([radial, edge_attr], dim=1)
+        e_out = self.phi(e_input)
+        m_ij = x_diff * e_out
+        if self.clamp:
+            m_ij = torch.clamp(m_ij, min=-100, max=100)
+        return m_ij
+
+    def node_model(self, x, edge_index, edge_attr):
+        row, col = edge_index
+        agg = unsorted_segment_mean(edge_attr, row, num_segments=x.size(0))
+        x_out = x + agg - x*self.reg
+        return x_out
+
+
+class E_GCL(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, clamp=False, norm_diff=False, tanh=False):
+        super(E_GCL, self).__init__()
+        input_edge = input_nf * 2
+        self.coords_weight = coords_weight
+        self.recurrent = recurrent
+        self.attention = attention
+        self.norm_diff = norm_diff
+        self.tanh = tanh
+        edge_coords_nf = 1
+
+
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(input_edge + edge_coords_nf + edges_in_d, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf),
+            act_fn)
+
+        self.node_mlp = nn.Sequential(
+            nn.Linear(hidden_nf + input_nf + nodes_att_dim, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, output_nf))
+
+        layer = nn.Linear(hidden_nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+
+        self.clamp = clamp
+        coord_mlp = []
+        coord_mlp.append(nn.Linear(hidden_nf, hidden_nf))
+        coord_mlp.append(act_fn)
+        coord_mlp.append(layer)
+        if self.tanh:
+            coord_mlp.append(nn.Tanh())
+            self.coords_range = nn.Parameter(torch.ones(1))*3
+        self.coord_mlp = nn.Sequential(*coord_mlp)
+
+
+        if self.attention:
+            self.att_mlp = nn.Sequential(
+                nn.Linear(hidden_nf, 1),
+                nn.Sigmoid())
+
+        #if recurrent:
+        #    self.gru = nn.GRUCell(hidden_nf, hidden_nf)
+
+
+    def edge_model(self, source, target, radial, edge_attr):
+        if edge_attr is None:  # Unused.
+            out = torch.cat([source, target, radial], dim=1)
+        else:
+            out = torch.cat([source, target, radial, edge_attr], dim=1)
+        out = self.edge_mlp(out)
+        if self.attention:
+            att_val = self.att_mlp(out)
+            out = out * att_val
+        return out
+
+    def node_model(self, x, edge_index, edge_attr, node_attr):
+        row, col = edge_index
+        agg = unsorted_segment_sum(edge_attr, row, num_segments=x.size(0))
+        if node_attr is not None:
+            agg = torch.cat([x, agg, node_attr], dim=1)
+        else:
+            agg = torch.cat([x, agg], dim=1)
+        out = self.node_mlp(agg)
+        if self.recurrent:
+            out = x + out
+        return out, agg
+
+    def coord_model(self, coord, edge_index, coord_diff, edge_feat):
+        row, col = edge_index
+        trans = coord_diff * self.coord_mlp(edge_feat)
+        trans = torch.clamp(trans, min=-100, max=100) #This is never activated but just in case it case it explosed it may save the train
+        agg = unsorted_segment_mean(trans, row, num_segments=coord.size(0))
+        coord += agg*self.coords_weight
+        return coord
+
+
+    def coord2radial(self, edge_index, coord):
+        row, col = edge_index
+        coord_diff = coord[row] - coord[col]
+        radial = torch.sum((coord_diff)**2, 1).unsqueeze(1)
+
+        if self.norm_diff:
+            norm = torch.sqrt(radial) + 1
+            coord_diff = coord_diff/(norm)
+
+        return radial, coord_diff
+
+    def forward(self, h, edge_index, coord, edge_attr=None, node_attr=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+        # coord = self.node_coord_model(h, coord)
+        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
+        return h, coord, edge_attr
+
+
+class E_GCL_vel(E_GCL):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, norm_diff=False, tanh=False):
+        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_att_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention, norm_diff=norm_diff, tanh=tanh)
+        self.norm_diff = norm_diff
+        self.coord_mlp_vel = nn.Sequential(
+            nn.Linear(input_nf, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, 1))
+
+    def forward(self, h, edge_index, coord, vel, edge_attr=None, node_attr=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
+
+
+        coord += self.coord_mlp_vel(h) * vel
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+        # coord = self.node_coord_model(h, coord)
+        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
+        return h, coord, edge_attr
+
+
+
+
+class GCL_rf_vel(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+    def __init__(self,  nf=64, edge_attr_nf=0, act_fn=nn.LeakyReLU(0.2), coords_weight=1.0):
+        super(GCL_rf_vel, self).__init__()
+        self.coords_weight = coords_weight
+        self.coord_mlp_vel = nn.Sequential(
+            nn.Linear(1, nf),
+            act_fn,
+            nn.Linear(nf, 1))
+
+        layer = nn.Linear(nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+        #layer.weight.uniform_(-0.1, 0.1)
+        self.phi = nn.Sequential(nn.Linear(1 + edge_attr_nf, nf),
+                                 act_fn,
+                                 layer,
+                                 nn.Tanh()) #we had to add the tanh to keep this method stable
+
+    def forward(self, x, vel_norm, vel, edge_index, edge_attr=None):
+        row, col = edge_index
+        edge_m = self.edge_model(x[row], x[col], edge_attr)
+        x = self.node_model(x, edge_index, edge_m)
+        x += vel * self.coord_mlp_vel(vel_norm)
+        return x, edge_attr
+
+    def edge_model(self, source, target, edge_attr):
+        x_diff = source - target
+        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
+        e_input = torch.cat([radial, edge_attr], dim=1)
+        e_out = self.phi(e_input)
+        m_ij = x_diff * e_out
+        return m_ij
+
+    def node_model(self, x, edge_index, edge_m):
+        row, col = edge_index
+        agg = unsorted_segment_mean(edge_m, row, num_segments=x.size(0))
+        x_out = x + agg * self.coords_weight
+        return x_out
+
+
+def unsorted_segment_sum(data, segment_ids, num_segments):
+    """Custom PyTorch op to replicate TensorFlow's `unsorted_segment_sum`."""
+    result_shape = (num_segments, data.size(1))
+    result = data.new_full(result_shape, 0)  # Init empty result tensor.
+    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
+    result.scatter_add_(0, segment_ids, data)
+    return result
+
+
+def unsorted_segment_mean(data, segment_ids, num_segments):
+    result_shape = (num_segments, data.size(1))
+    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
+    result = data.new_full(result_shape, 0)  # Init empty result tensor.
+    count = data.new_full(result_shape, 0)
+    result.scatter_add_(0, segment_ids, data)
+    count.scatter_add_(0, segment_ids, torch.ones_like(data))
+    return result / count.clamp(min=1)
\ No newline at end of file

From 5ab8a08d956f2e1c01f24a476a0b6e8264683997 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 13:21:45 +0100
Subject: [PATCH 160/286] fix merg conflict

---
 .../jastrows/elec_elec/test_generic_jastrow.py        |  9 ---------
 .../jastrows/elec_elec/test_pade_jastrow.py           | 10 ----------
 .../jastrows/elec_elec/test_pade_jastrow_polynom.py   | 10 ----------
 .../jastrows/elec_elec/test_scaled_pade_jastrow.py    |  9 ---------
 .../elec_elec/test_scaled_pade_jastrow_polynom.py     | 11 -----------
 .../test_three_body_jastrow_boys_handy.py             |  9 ---------
 .../test_three_body_jastrow_fully_connected.py        |  9 ---------
 .../elec_nuc/test_electron_nuclei_fully_connected.py  |  9 ---------
 .../elec_nuc/test_electron_nuclei_pade_jastrow.py     | 10 ----------
 tests/wavefunction/jastrows/test_combined_terms.py    |  7 -------
 10 files changed, 93 deletions(-)

diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index eefdd4cc..697af246 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -2,22 +2,13 @@
 import numpy as np
 import torch
 
-<<<<<<< HEAD
 
 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.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
->>>>>>> master
 
 set_torch_double_precision()
 
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index dfa31118..7d69096b 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -2,21 +2,11 @@
 import numpy as np
 import torch
 
-<<<<<<< HEAD
 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.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
->>>>>>> master
 
 set_torch_double_precision()
 
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 9c2bf1be..d9144999 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -2,23 +2,13 @@
 import numpy as np
 import torch
 
-<<<<<<< HEAD
 
 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.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
->>>>>>> master
 
 set_torch_double_precision()
 
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 688ab77a..e5fb91da 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -2,21 +2,12 @@
 import numpy as np
 import torch
 
-<<<<<<< HEAD
 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.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
->>>>>>> master
 
 set_torch_double_precision()
 
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 178b1d13..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
@@ -2,23 +2,12 @@
 import numpy as np
 import torch
 
-<<<<<<< HEAD
 
 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.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
->>>>>>> master
 
 set_torch_double_precision()
 
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 81595ab9..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
@@ -3,18 +3,9 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-<<<<<<< HEAD
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
-    BoysHandyJastrowKernel,
-)
-=======
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 from qmctorch.utils import set_torch_double_precision
->>>>>>> master
 
 set_torch_double_precision()
 
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 77690504..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
@@ -3,18 +3,9 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-<<<<<<< HEAD
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
-    FullyConnectedJastrowKernel,
-)
-=======
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 from qmctorch.utils import set_torch_double_precision
->>>>>>> master
 
 set_torch_double_precision()
 
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 3228d5fd..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
@@ -3,18 +3,9 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-<<<<<<< HEAD
-from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
-    JastrowFactorElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
-    FullyConnectedJastrowKernel,
-)
-=======
 from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
 from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import FullyConnectedJastrowKernel
 from qmctorch.utils import set_torch_double_precision
->>>>>>> master
 
 set_torch_double_precision()
 
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 a5dc0aaf..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
@@ -3,19 +3,9 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad, gradcheck
-
-<<<<<<< HEAD
-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.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
->>>>>>> master
 
 set_torch_double_precision()
 
diff --git a/tests/wavefunction/jastrows/test_combined_terms.py b/tests/wavefunction/jastrows/test_combined_terms.py
index 7c24a9c9..5ea717db 100644
--- a/tests/wavefunction/jastrows/test_combined_terms.py
+++ b/tests/wavefunction/jastrows/test_combined_terms.py
@@ -4,7 +4,6 @@
 import torch
 from torch.autograd import Variable, grad, gradcheck
 
-<<<<<<< HEAD
 from qmctorch.wavefunction.jastrows.jastrow_factor_combined_terms import (
     JastrowFactorCombinedTerms,
 )
@@ -17,13 +16,7 @@
 from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels import (
     BoysHandyJastrowKernel,
 )
-=======
-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.utils import set_torch_double_precision
->>>>>>> master
 
 set_torch_double_precision()
 

From dacd24c9c3e636945d0637265f4707a7b80b01e3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 13:38:59 +0100
Subject: [PATCH 161/286] fix last conflict

---
 tests/wavefunction/test_compare_slaterjastrow_backflow.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index 12fef4cb..64d8e722 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -2,7 +2,6 @@
 import torch
 import unittest
 
-<<<<<<< HEAD
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 
@@ -19,13 +18,7 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
-
-torch.set_default_tensor_type(torch.DoubleTensor)
-
-=======
-# set_torch_double_precision()
 set_torch_double_precision()
->>>>>>> master
 
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
     def setUp(self):

From 1244a30129014e30f63d690360ec1bbd2aee53be Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 13:48:44 +0100
Subject: [PATCH 162/286] fx last comflic

---
 tests/wavefunction/test_slatercombinedjastrow_backflow.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 54abaf57..018fff97 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -2,7 +2,6 @@
 import torch
 import unittest
 
-<<<<<<< HEAD
 from .base_test_cases import BaseTestCases
 
 from qmctorch.scf import Molecule
@@ -29,12 +28,7 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
-
-
-torch.set_default_tensor_type(torch.DoubleTensor)
-=======
 set_torch_double_precision()
->>>>>>> master
 
 
 class TestSlaterJastrowBackFlow(BaseTestCases.BackFlowWaveFunctionBaseTest):

From 517dfce5892245492215f9bbb5d1163a7a93acb4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 13:54:28 +0100
Subject: [PATCH 163/286] remove graph jastrow

---
 .../wavefunction/jastrows/graph/__init__.py   |   4 -
 .../jastrows/graph/egnn/__init__.py           |   0
 .../wavefunction/jastrows/graph/egnn/egnn.py  |  88 -----
 .../wavefunction/jastrows/graph/egnn/gcl.py   | 351 ------------------
 .../jastrows/graph/elec_elec_graph.py         |  45 ---
 .../jastrows/graph/elec_nuc_graph.py          |  83 -----
 .../jastrows/graph/jastrow_graph.py           | 265 -------------
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 315 ----------------
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  97 -----
 tests/wavefunction/jastrows/graph/__init__.py |   0
 .../jastrows/graph/test_graph_jastrow.py      | 114 ------
 12 files changed, 1362 deletions(-)
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
 delete mode 100644 tests/wavefunction/jastrows/graph/__init__.py
 delete mode 100644 tests/wavefunction/jastrows/graph/test_graph_jastrow.py

diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
deleted file mode 100644
index af55bd1c..00000000
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from .jastrow_graph import JastrowFactorGraph as JastrowFactor
-from .mgcn.mgcn_predictor import MGCNPredictor
-
-__all__ = ["JastrowFactor", "MGCNPredictor"]
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py b/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
deleted file mode 100644
index 47e18648..00000000
--- a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from models.gcl import E_GCL, unsorted_segment_sum
-import torch
-from torch import nn
-
-
-class E_GCL_mask(E_GCL):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_attr_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False):
-        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_attr_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention)
-
-        del self.coord_mlp
-        self.act_fn = act_fn
-
-    def coord_model(self, coord, edge_index, coord_diff, edge_feat, edge_mask):
-        row, col = edge_index
-        trans = coord_diff * self.coord_mlp(edge_feat) * edge_mask
-        agg = unsorted_segment_sum(trans, row, num_segments=coord.size(0))
-        coord += agg*self.coords_weight
-        return coord
-
-    def forward(self, h, edge_index, coord, node_mask, edge_mask, edge_attr=None, node_attr=None, n_nodes=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-
-        edge_feat = edge_feat * edge_mask
-
-        # TO DO: edge_feat = edge_feat * edge_mask
-
-        #coord = self.coord_model(coord, edge_index, coord_diff, edge_feat, edge_mask)
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-
-        return h, coord, edge_attr
-
-
-
-class EGNN(nn.Module):
-    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, device='cpu', act_fn=nn.SiLU(), n_layers=4, coords_weight=1.0, attention=False, node_attr=1):
-        super(EGNN, self).__init__()
-        self.hidden_nf = hidden_nf
-        self.device = device
-        self.n_layers = n_layers
-
-        ### Encoder
-        self.embedding = nn.Linear(in_node_nf, hidden_nf)
-        self.node_attr = node_attr
-        if node_attr:
-            n_node_attr = in_node_nf
-        else:
-            n_node_attr = 0
-        for i in range(0, n_layers):
-            self.add_module("gcl_%d" % i, E_GCL_mask(self.hidden_nf, self.hidden_nf, self.hidden_nf, edges_in_d=in_edge_nf, nodes_attr_dim=n_node_attr, act_fn=act_fn, recurrent=True, coords_weight=coords_weight, attention=attention))
-
-        self.node_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
-                                      act_fn,
-                                      nn.Linear(self.hidden_nf, self.hidden_nf))
-
-        self.graph_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
-                                       act_fn,
-                                       nn.Linear(self.hidden_nf, 1))
-        self.to(self.device)
-
-    def forward(self, h0, x, edges, edge_attr, node_mask, edge_mask, n_nodes):
-        h = self.embedding(h0)
-        for i in range(0, self.n_layers):
-            if self.node_attr:
-                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr, node_attr=h0, n_nodes=n_nodes)
-            else:
-                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr,
-                                                      node_attr=None, n_nodes=n_nodes)
-
-        h = self.node_dec(h)
-        h = h * node_mask
-        h = h.view(-1, n_nodes, self.hidden_nf)
-        h = torch.sum(h, dim=1)
-        pred = self.graph_dec(h)
-        return pred.squeeze(1)
-
-
-
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
deleted file mode 100644
index 3d1aebfd..00000000
--- a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
+++ /dev/null
@@ -1,351 +0,0 @@
-from torch import nn
-import torch
-
-class MLP(nn.Module):
-    """ a simple 4-layer MLP """
-
-    def __init__(self, nin, nout, nh):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(nin, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nout),
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-class GCL_basic(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self):
-        super(GCL_basic, self).__init__()
-
-
-    def edge_model(self, source, target, edge_attr):
-        pass
-
-    def node_model(self, h, edge_index, edge_attr):
-        pass
-
-    def forward(self, x, edge_index, edge_attr=None):
-        row, col = edge_index
-        edge_feat = self.edge_model(x[row], x[col], edge_attr)
-        x = self.node_model(x, edge_index, edge_feat)
-        return x, edge_feat
-
-
-
-class GCL(GCL_basic):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_nf=0, act_fn=nn.ReLU(), bias=True, attention=False, t_eq=False, recurrent=True):
-        super(GCL, self).__init__()
-        self.attention = attention
-        self.t_eq=t_eq
-        self.recurrent = recurrent
-        input_edge_nf = input_nf * 2
-        self.edge_mlp = nn.Sequential(
-            nn.Linear(input_edge_nf + edges_in_nf, hidden_nf, bias=bias),
-            act_fn,
-            nn.Linear(hidden_nf, hidden_nf, bias=bias),
-            act_fn)
-        if self.attention:
-            self.att_mlp = nn.Sequential(
-                nn.Linear(input_nf, hidden_nf, bias=bias),
-                act_fn,
-                nn.Linear(hidden_nf, 1, bias=bias),
-                nn.Sigmoid())
-
-
-        self.node_mlp = nn.Sequential(
-            nn.Linear(hidden_nf + input_nf, hidden_nf, bias=bias),
-            act_fn,
-            nn.Linear(hidden_nf, output_nf, bias=bias))
-
-        #if recurrent:
-            #self.gru = nn.GRUCell(hidden_nf, hidden_nf)
-
-
-    def edge_model(self, source, target, edge_attr):
-        edge_in = torch.cat([source, target], dim=1)
-        if edge_attr is not None:
-            edge_in = torch.cat([edge_in, edge_attr], dim=1)
-        out = self.edge_mlp(edge_in)
-        if self.attention:
-            att = self.att_mlp(torch.abs(source - target))
-            out = out * att
-        return out
-
-    def node_model(self, h, edge_index, edge_attr):
-        row, col = edge_index
-        agg = unsorted_segment_sum(edge_attr, row, num_segments=h.size(0))
-        out = torch.cat([h, agg], dim=1)
-        out = self.node_mlp(out)
-        if self.recurrent:
-            out = out + h
-            #out = self.gru(out, h)
-        return out
-
-
-class GCL_rf(GCL_basic):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, nf=64, edge_attr_nf=0, reg=0, act_fn=nn.LeakyReLU(0.2), clamp=False):
-        super(GCL_rf, self).__init__()
-
-        self.clamp = clamp
-        layer = nn.Linear(nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-        self.phi = nn.Sequential(nn.Linear(edge_attr_nf + 1, nf),
-                                 act_fn,
-                                 layer)
-        self.reg = reg
-
-    def edge_model(self, source, target, edge_attr):
-        x_diff = source - target
-        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
-        e_input = torch.cat([radial, edge_attr], dim=1)
-        e_out = self.phi(e_input)
-        m_ij = x_diff * e_out
-        if self.clamp:
-            m_ij = torch.clamp(m_ij, min=-100, max=100)
-        return m_ij
-
-    def node_model(self, x, edge_index, edge_attr):
-        row, col = edge_index
-        agg = unsorted_segment_mean(edge_attr, row, num_segments=x.size(0))
-        x_out = x + agg - x*self.reg
-        return x_out
-
-
-class E_GCL(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, clamp=False, norm_diff=False, tanh=False):
-        super(E_GCL, self).__init__()
-        input_edge = input_nf * 2
-        self.coords_weight = coords_weight
-        self.recurrent = recurrent
-        self.attention = attention
-        self.norm_diff = norm_diff
-        self.tanh = tanh
-        edge_coords_nf = 1
-
-
-        self.edge_mlp = nn.Sequential(
-            nn.Linear(input_edge + edge_coords_nf + edges_in_d, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, hidden_nf),
-            act_fn)
-
-        self.node_mlp = nn.Sequential(
-            nn.Linear(hidden_nf + input_nf + nodes_att_dim, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, output_nf))
-
-        layer = nn.Linear(hidden_nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-
-        self.clamp = clamp
-        coord_mlp = []
-        coord_mlp.append(nn.Linear(hidden_nf, hidden_nf))
-        coord_mlp.append(act_fn)
-        coord_mlp.append(layer)
-        if self.tanh:
-            coord_mlp.append(nn.Tanh())
-            self.coords_range = nn.Parameter(torch.ones(1))*3
-        self.coord_mlp = nn.Sequential(*coord_mlp)
-
-
-        if self.attention:
-            self.att_mlp = nn.Sequential(
-                nn.Linear(hidden_nf, 1),
-                nn.Sigmoid())
-
-        #if recurrent:
-        #    self.gru = nn.GRUCell(hidden_nf, hidden_nf)
-
-
-    def edge_model(self, source, target, radial, edge_attr):
-        if edge_attr is None:  # Unused.
-            out = torch.cat([source, target, radial], dim=1)
-        else:
-            out = torch.cat([source, target, radial, edge_attr], dim=1)
-        out = self.edge_mlp(out)
-        if self.attention:
-            att_val = self.att_mlp(out)
-            out = out * att_val
-        return out
-
-    def node_model(self, x, edge_index, edge_attr, node_attr):
-        row, col = edge_index
-        agg = unsorted_segment_sum(edge_attr, row, num_segments=x.size(0))
-        if node_attr is not None:
-            agg = torch.cat([x, agg, node_attr], dim=1)
-        else:
-            agg = torch.cat([x, agg], dim=1)
-        out = self.node_mlp(agg)
-        if self.recurrent:
-            out = x + out
-        return out, agg
-
-    def coord_model(self, coord, edge_index, coord_diff, edge_feat):
-        row, col = edge_index
-        trans = coord_diff * self.coord_mlp(edge_feat)
-        trans = torch.clamp(trans, min=-100, max=100) #This is never activated but just in case it case it explosed it may save the train
-        agg = unsorted_segment_mean(trans, row, num_segments=coord.size(0))
-        coord += agg*self.coords_weight
-        return coord
-
-
-    def coord2radial(self, edge_index, coord):
-        row, col = edge_index
-        coord_diff = coord[row] - coord[col]
-        radial = torch.sum((coord_diff)**2, 1).unsqueeze(1)
-
-        if self.norm_diff:
-            norm = torch.sqrt(radial) + 1
-            coord_diff = coord_diff/(norm)
-
-        return radial, coord_diff
-
-    def forward(self, h, edge_index, coord, edge_attr=None, node_attr=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-        # coord = self.node_coord_model(h, coord)
-        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
-        return h, coord, edge_attr
-
-
-class E_GCL_vel(E_GCL):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, norm_diff=False, tanh=False):
-        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_att_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention, norm_diff=norm_diff, tanh=tanh)
-        self.norm_diff = norm_diff
-        self.coord_mlp_vel = nn.Sequential(
-            nn.Linear(input_nf, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, 1))
-
-    def forward(self, h, edge_index, coord, vel, edge_attr=None, node_attr=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
-
-
-        coord += self.coord_mlp_vel(h) * vel
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-        # coord = self.node_coord_model(h, coord)
-        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
-        return h, coord, edge_attr
-
-
-
-
-class GCL_rf_vel(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-    def __init__(self,  nf=64, edge_attr_nf=0, act_fn=nn.LeakyReLU(0.2), coords_weight=1.0):
-        super(GCL_rf_vel, self).__init__()
-        self.coords_weight = coords_weight
-        self.coord_mlp_vel = nn.Sequential(
-            nn.Linear(1, nf),
-            act_fn,
-            nn.Linear(nf, 1))
-
-        layer = nn.Linear(nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-        #layer.weight.uniform_(-0.1, 0.1)
-        self.phi = nn.Sequential(nn.Linear(1 + edge_attr_nf, nf),
-                                 act_fn,
-                                 layer,
-                                 nn.Tanh()) #we had to add the tanh to keep this method stable
-
-    def forward(self, x, vel_norm, vel, edge_index, edge_attr=None):
-        row, col = edge_index
-        edge_m = self.edge_model(x[row], x[col], edge_attr)
-        x = self.node_model(x, edge_index, edge_m)
-        x += vel * self.coord_mlp_vel(vel_norm)
-        return x, edge_attr
-
-    def edge_model(self, source, target, edge_attr):
-        x_diff = source - target
-        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
-        e_input = torch.cat([radial, edge_attr], dim=1)
-        e_out = self.phi(e_input)
-        m_ij = x_diff * e_out
-        return m_ij
-
-    def node_model(self, x, edge_index, edge_m):
-        row, col = edge_index
-        agg = unsorted_segment_mean(edge_m, row, num_segments=x.size(0))
-        x_out = x + agg * self.coords_weight
-        return x_out
-
-
-def unsorted_segment_sum(data, segment_ids, num_segments):
-    """Custom PyTorch op to replicate TensorFlow's `unsorted_segment_sum`."""
-    result_shape = (num_segments, data.size(1))
-    result = data.new_full(result_shape, 0)  # Init empty result tensor.
-    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
-    result.scatter_add_(0, segment_ids, data)
-    return result
-
-
-def unsorted_segment_mean(data, segment_ids, num_segments):
-    result_shape = (num_segments, data.size(1))
-    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
-    result = data.new_full(result_shape, 0)  # Init empty result tensor.
-    count = data.new_full(result_shape, 0)
-    result.scatter_add_(0, segment_ids, data)
-    count.scatter_add_(0, segment_ids, torch.ones_like(data))
-    return result / count.clamp(min=1)
\ 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
deleted file mode 100644
index 35a8f7f9..00000000
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import dgl
-import torch
-
-
-def ElecElecGraph(nelec, nup):
-    """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):
-    """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, nup):
-    """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
deleted file mode 100644
index 0cb22dc8..00000000
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import dgl
-import torch
-from mendeleev import element
-
-
-def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
-    """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, nelec):
-    """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, atom_types, atomic_features, nelec, nup):
-    """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, atomic_features):
-    """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/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
deleted file mode 100644
index a2c409c1..00000000
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ /dev/null
@@ -1,265 +0,0 @@
-import torch
-from torch import nn
-from torch.autograd import grad
-import dgl
-
-from .mgcn.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
-
-
-class JastrowFactorGraph(nn.Module):
-    def __init__(
-        self,
-        mol,
-        ee_model=MGCNPredictor,
-        ee_model_kwargs={},
-        en_model=MGCNPredictor,
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-    ):
-        """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 = ee_model(**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 = en_model(**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 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) 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, en_kernel):
-        """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, ee_kernel, en_kernel, sum_grad):
-        """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, ee_kernel, en_kernel, sum_grad=False, return_all=False
-    ):
-        """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):
-        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):
-        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):
-        """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/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
deleted file mode 100644
index 4b69b18e..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import dgl.function as fn
-import torch
-import torch.nn as nn
-
-from dgllife.model.gnn.schnet import RBFExpansion
-
-
-class EdgeEmbedding(nn.Module):
-    """Module for embedding edges.
-
-    Edges whose end nodes have the same combination of types
-    share the same initial embedding.
-
-    Parameters
-    ----------
-    num_types : int
-        Number of edge types to embed.
-    edge_feats : int
-        Size for the edge representations to learn.
-    """
-
-    def __init__(self, num_types, edge_feats):
-        super(EdgeEmbedding, self).__init__()
-        self.embed = nn.Embedding(num_types, edge_feats)
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.embed.reset_parameters()
-
-    def get_edge_types(self, edges):
-        """Generates edge types.
-
-        The edge type is based on the type of the source and destination nodes.
-        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
-
-        To map each pair of node types to a unique number, we use an unordered pairing function.
-        See more details in this discussion:
-        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
-        Note that the number of edge types should be larger than the square of the maximum node
-        type in the dataset.
-
-        Parameters
-        ----------
-        edges : EdgeBatch
-            Container for a batch of edges.
-
-        Returns
-        -------
-        dict
-            Mapping 'type' to the computed edge types.
-        """
-        node_type1 = edges.src["type"]
-        node_type2 = edges.dst["type"]
-        return {
-            "type": node_type1 * node_type2
-            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
-        }
-
-    def forward(self, g, node_types):
-        """Embeds edge types.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-
-        Returns
-        -------
-        float32 tensor of shape (E, edge_feats)
-            Edge representations.
-        """
-        g = g.local_var()
-        g.ndata["type"] = node_types
-        g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata["type"])
-
-
-class VEConv(nn.Module):
-    """Vertex-Edge Convolution in MGCN
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This layer combines both node and edge features in updating node representations.
-
-    Parameters
-    ----------
-    dist_feats : int
-        Size for the expanded distances.
-    feats : int
-        Size for the input and output node and edge representations.
-    update_edge : bool
-        Whether to update edge representations. Default to True.
-    """
-
-    def __init__(self, dist_feats, feats, update_edge=True):
-        super(VEConv, self).__init__()
-
-        self.update_dists = nn.Sequential(
-            nn.Linear(dist_feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        if update_edge:
-            self.update_edge_feats = nn.Linear(feats, feats)
-        else:
-            self.update_edge_feats = None
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        for layer in self.update_dists:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-
-        if self.update_edge_feats is not None:
-            self.update_edge_feats.reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features.
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Edge representations, updated if ``update_edge == True`` in initialization.
-        """
-        expanded_dists = self.update_dists(expanded_dists)
-        if self.update_edge_feats is not None:
-            edge_feats = self.update_edge_feats(edge_feats)
-
-        g = g.local_var()
-        g.ndata.update({"hv": node_feats})
-        g.edata.update({"dist": expanded_dists, "he": edge_feats})
-        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
-        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
-        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
-
-        return node_feats, edge_feats
-
-
-class MultiLevelInteraction(nn.Module):
-    """Building block for MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
-    edge features and expanded distances in message passing and updates node and edge
-    representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the input and output node and edge representations.
-    dist_feats : int
-        Size for the expanded distances.
-    """
-
-    def __init__(self, feats, dist_feats):
-        super(MultiLevelInteraction, self).__init__()
-
-        self.project_in_node_feats = nn.Linear(feats, feats)
-        self.conv = VEConv(dist_feats, feats)
-        self.project_out_node_feats = nn.Sequential(
-            nn.Linear(feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
-        )
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.project_in_node_feats.reset_parameters()
-        self.conv.reset_parameters()
-        for layer in self.project_out_node_feats:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-        self.project_edge_feats[0].reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Updated edge representations.
-        """
-        new_node_feats = self.project_in_node_feats(node_feats)
-        new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists
-        )
-        new_node_feats = self.project_out_node_feats(new_node_feats)
-        node_feats = node_feats + new_node_feats
-
-        edge_feats = self.project_edge_feats(edge_feats)
-
-        return node_feats, edge_feats
-
-
-class MGCNGNN(nn.Module):
-    """MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This class performs message passing in MGCN and returns the updated node representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 30.
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 0.1.
-    """
-
-    def __init__(  # pylint: disable=to-many-arguments
-        self,
-        feats=128,
-        n_layers=3,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=30.0,
-        gap=0.1,
-    ):
-        super(MGCNGNN, self).__init__()
-
-        self.node_embed = nn.Embedding(num_node_types, feats)
-        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
-        self.high = cutoff
-        self.gap = gap
-        self.rbf = RBFExpansion(high=cutoff, gap=gap)
-
-        self.gnn_layers = nn.ModuleList()
-        for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.node_embed.reset_parameters()
-        self.edge_embed.reset_parameters()
-        self.rbf.reset_parameters()
-
-        for layer in self.gnn_layers:
-            layer.reset_parameters()
-
-    def forward(self, g, node_types, edge_dists):
-        """Performs message passing and updates node representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (V, feats * (n_layers + 1))
-            Output node representations.
-        """
-
-        node_feats = self.node_embed(node_types)
-        edge_feats = self.edge_embed(g, node_types)
-        expanded_dists = self.rbf(edge_dists)
-
-        all_layer_node_feats = [node_feats]
-        for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
-            all_layer_node_feats.append(node_feats)
-        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
deleted file mode 100644
index 9f710fd3..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import torch.nn as nn
-from dgllife.model.readout import MLPNodeReadout
-from .mgcn import MGCNGNN
-
-
-class MGCNPredictor(nn.Module):
-    """MGCN for for regression and classification on graphs.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    classifier_hidden_feats : int
-        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
-        representations in the classifier. Default to 64.
-    n_tasks : int
-        Number of tasks, which is also the output size. Default to 1.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 5.0
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 1.0
-    predictor_hidden_feats : int
-        Size for hidden representations in the output MLP predictor. Default to 64.
-    """
-
-    def __init__(
-        self,
-        feats=128,
-        n_layers=3,
-        classifier_hidden_feats=64,
-        n_tasks=1,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=5.0,
-        gap=1.0,
-        predictor_hidden_feats=64,
-    ):
-        super(MGCNPredictor, self).__init__()
-
-        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print(
-                "classifier_hidden_feats is deprecated and will be removed in the future, "
-                "use predictor_hidden_feats instead"
-            )
-            predictor_hidden_feats = classifier_hidden_feats
-
-        self.gnn = MGCNGNN(
-            feats=feats,
-            n_layers=n_layers,
-            num_node_types=num_node_types,
-            num_edge_types=num_edge_types,
-            cutoff=cutoff,
-            gap=gap,
-        )
-        self.readout = MLPNodeReadout(
-            node_feats=(n_layers + 1) * feats,
-            hidden_feats=predictor_hidden_feats,
-            graph_feats=n_tasks,
-            activation=nn.Softplus(beta=1, threshold=20),
-        )
-
-    def forward(self, g, node_types, edge_dists):
-        """Graph-level regression/soft classification.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (G, n_tasks)
-            Prediction for the graphs in the batch. G for the number of graphs.
-        """
-        node_feats = self.gnn(g, node_types, edge_dists)
-        return self.readout(g, node_feats)
diff --git a/tests/wavefunction/jastrows/graph/__init__.py b/tests/wavefunction/jastrows/graph/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
deleted file mode 100644
index 67ac08ab..00000000
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import unittest
-import numpy as np
-import torch
-from torch.autograd import Variable, grad
-from types import SimpleNamespace
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
-from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
-
-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 = JastrowFactorGraph(
-            self.mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            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()

From 860fcdb63c372c15339899a1076b480c641b29c0 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 13:55:09 +0100
Subject: [PATCH 164/286] remove dgl deps

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index dfc4f30b..61d0f27e 100644
--- a/setup.py
+++ b/setup.py
@@ -41,7 +41,7 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch', 'dgl', 'dgllife',
+                      'scipy', 'tqdm', 'torch',
                       'plams', 'pints',
                       'pyscf', 'mendeleev', 'twiggy',
                       'plams', 'mpi4py'],

From 64fbff2335b1b1fcf179adf44cde6f5f2512b80b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 14:07:21 +0100
Subject: [PATCH 165/286] remove graph

---
 docs/example/jast_graph.py                    |  19 --
 notebooks/GNNJastrow.ipynb                    | 213 ------------------
 .../test_slater_mgcn_graph_jastrow.py         | 176 ---------------
 3 files changed, 408 deletions(-)
 delete mode 100644 docs/example/jast_graph.py
 delete mode 100644 notebooks/GNNJastrow.ipynb
 delete mode 100644 tests/wavefunction/test_slater_mgcn_graph_jastrow.py

diff --git a/docs/example/jast_graph.py b/docs/example/jast_graph.py
deleted file mode 100644
index 4df30937..00000000
--- a/docs/example/jast_graph.py
+++ /dev/null
@@ -1,19 +0,0 @@
-
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
-import torch
-from torch.autograd import grad
-nup = 2
-ndown = 2
-atomic_pos = torch.rand(2, 3)
-atom_types = ["Li", "H"]
-jast = JastrowFactorGraph(nup, ndown,
-                          atomic_pos,
-                          atom_types)
-
-
-pos = torch.rand(10, 12)
-pos.requires_grad = True
-jval = jast(pos)
-
-gval = jast(pos, derivative=1)
-hval = jast(pos, derivative=2)
diff --git a/notebooks/GNNJastrow.ipynb b/notebooks/GNNJastrow.ipynb
deleted file mode 100644
index e16bf31a..00000000
--- a/notebooks/GNNJastrow.ipynb
+++ /dev/null
@@ -1,213 +0,0 @@
-{
- "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": [
-    "# Graph Neural Networks\n",
-    "\n",
-    "There has been a lot of work done on graph neural networks. See for example the Deep Graph Library (https://www.dgl.ai/) and its application to chemistry https://github.com/awslabs/dgl-lifesci \n",
-    "\n",
-    "In particular the paper Molecular Property Prediction: A Multilevel Quantum Interactions Modeling Perspective (https://arxiv.org/abs/1906.11081) already implemented in dgl-lifesci (https://github.com/awslabs/dgl-lifesci/blob/master/examples/README.md) offers an interesting way of extending the defintion of the Jastrow Factors"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# GNN Jastrow Factors\n",
-    "\n",
-    "\n",
-    "Instead of defining the Electorn-Electron Jastrow factor through the Pade Jastrow or the FullyConnected Netowrk we can consider the different connection graphs and use these graph as an input of graph network. \n",
-    "\n",
-    "\n",
-    "\n",
-    "W can first consider the connection graph between all the elctrons. In this input graph each node represent a given electron and an edge exists between all electron pairs. The distance between two electron can be used as an edge feature to encode the relative positions of the electrons\n",
-    "\n",
-    "We can also consider the connection graphs between the electrons and the nuclei. In this graph each electron is represented by a node and each atom is also represented by a node. Edges exists only between electron and atoms biut not between electron pairs (we can optionally consider edges between nuclei)\n",
-    "\n",
-    "Expressing the structure of the electron/nuclei system as a graph allows expressing different interactions, e.g. elec-elec terms, elec-elec-elec termsn, elec-nuclei, elec-elec-nuclei, etc ... in a very flexible way through convolution over the graphs. (see https://arxiv.org/abs/1906.11081)\n",
-    "\n",
-    "The `JastrowFactorGraph` orchestrate the calculation of such Jastrow factor and accept different graph neural network for the elec-elec graphs and the elec-nuc graphs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph\n",
-    "from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor\n",
-    "\n",
-    "nup, ndown = 2, 2\n",
-    "nelec = nup + ndown\n",
-    "\n",
-    "atom_types = [\"Li\", \"H\"]\n",
-    "atomic_pos = torch.tensor([[0., 0., 0.],\n",
-    "                           [0., 0., 3.015]])\n",
-    "\n",
-    "\n",
-    "jastrow = JastrowFactorGraph(nup, ndown,\n",
-    "                                  atomic_pos,\n",
-    "                                  atom_types,\n",
-    "                                  ee_model=MGCNPredictor,\n",
-    "                                  ee_model_kwargs={'n_layers': 3,\n",
-    "                                                   'feats': 32,\n",
-    "                                                   'cutoff': 5.0,\n",
-    "                                                   'gap': 1.},\n",
-    "                                  en_model=MGCNPredictor,\n",
-    "                                  en_model_kwargs={'n_layers': 3,\n",
-    "                                                   'feats': 32,\n",
-    "                                                   'cutoff': 5.0,\n",
-    "                                                   'gap': 1.0})\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SlaterJastrow wave function with MGCN\n",
-    "\n",
-    "The `SlaterJastrowGraph` class allows using GNN Jastrows in Slater-Jastrow wave function "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "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.85928101642664\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.859 Hartree\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : False\n",
-      "INFO:QMCTorch|  Highest MO included : 3\n",
-      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
-      "INFO:QMCTorch|  Number of confs     : 4\n",
-      "INFO:QMCTorch|  Kinetic energy      : auto\n",
-      "INFO:QMCTorch|  Number var  param   : 37\n",
-      "INFO:QMCTorch|  Cuda support        : False\n",
-      "INFO:QMCTorch|\n",
-      "INFO:QMCTorch| Wave Function\n",
-      "INFO:QMCTorch|  Jastrow factor      : True\n",
-      "INFO:QMCTorch|  Jastrow kernel      : Graph(ee:MGCNPredictor, en:MGCNPredictor)\n",
-      "INFO:QMCTorch|  Highest MO included : 3\n",
-      "INFO:QMCTorch|  Configurations      : single_double(2,2)\n",
-      "INFO:QMCTorch|  Number of confs     : 4\n",
-      "INFO:QMCTorch|  Kinetic energy      : auto\n",
-      "INFO:QMCTorch|  Number var  param   : 56263\n",
-      "INFO:QMCTorch|  Cuda support        : False\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "from qmctorch.scf import Molecule\n",
-    "from qmctorch.wavefunction import SlaterJastrowGraph\n",
-    "from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor\n",
-    "\n",
-    "\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",
-    "    redo_scf=True)\n",
-    "\n",
-    "wf = SlaterJastrowGraph( mol,\n",
-    "                         kinetic='auto',\n",
-    "                         include_all_mo=False,\n",
-    "                         configs='single_double(2,2)',\n",
-    "                         ee_model=MGCNPredictor,\n",
-    "                         ee_model_kwargs={'n_layers': 3,\n",
-    "                                          'feats': 32,\n",
-    "                                          'cutoff': 5.0,\n",
-    "                                          'gap': 1.},\n",
-    "                         en_model=MGCNPredictor,\n",
-    "                         en_model_kwargs={'n_layers': 3,\n",
-    "                                          'feats': 32,\n",
-    "                                          'cutoff': 5.0,\n",
-    "                                          'gap': 1.0})\n",
-    "\n",
-    "nbatch = 10\n",
-    "pos = torch.rand(nbatch,  wf.nelec*3)\n",
-    "\n",
-    "wfval = wf(pos)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# TODO Explore the different architectures of MGCN \n",
-    "\n",
-    "As for the Fully connected networks, it would be great assess the performance of MGCN jastrow factors in predicting the total energy of the test molecules (H2, LiH, Li2, N2). Of course MGCN are only one of the possible options and we can also define new GNN to compute the jastrows."
-   ]
-  },
-  {
-   "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/tests/wavefunction/test_slater_mgcn_graph_jastrow.py b/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
deleted file mode 100644
index 11ca4c4c..00000000
--- a/tests/wavefunction/test_slater_mgcn_graph_jastrow.py
+++ /dev/null
@@ -1,176 +0,0 @@
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction import SlaterJastrow
-from qmctorch.utils import set_torch_double_precision
-from qmctorch.wavefunction.jastrows.graph import JastrowFactor, MGCNPredictor
-
-from torch.autograd import grad, gradcheck, Variable
-
-import numpy as np
-import torch
-import unittest
-
-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 TestSlaterJastrowGraph(unittest.TestCase):
-    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 = JastrowFactor(
-            mol,
-            ee_model=MGCNPredictor,
-            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
-            en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-        )
-        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.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()

From f85f1f2b786ebb30bbe01ea1fcb8d6a22ee56a6a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 16:19:18 +0100
Subject: [PATCH 166/286] fix test

---
 .../orbital_dependent/test_generic_jastrow_orbital.py        | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

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..85e27efc 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
@@ -3,7 +3,7 @@
 
 
 import unittest
-
+from types import SimpleNamespace
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
@@ -48,9 +48,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

From 6b1149e475d02957cda1d5571dc93a3af35deaea Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 16:39:02 +0100
Subject: [PATCH 167/286] restrict to 3.8

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 765577b4..5b9b8aa7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['3.8', '3.10']
+        version: ['3.8']
 
     steps:
     - name: Cancel Previous Runs

From 2c298ac763d847fcd12d6257898862016a83a4b7 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 17:04:56 +0100
Subject: [PATCH 168/286] coday fix

---
 CHANGELOG.rst                                 | 26 +++++++++++++++++++
 .../test_generic_jastrow_orbital.py           |  4 ---
 2 files changed, 26 insertions(+), 4 deletions(-)

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/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 85e27efc..48131a2e 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,7 +1,3 @@
-import torch
-from torch.autograd import grad
-
-
 import unittest
 from types import SimpleNamespace
 import numpy as np

From 6dfa2a8bbd4254b25877ddb9aba46797c37f06ff Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 20 Dec 2024 17:42:25 +0100
Subject: [PATCH 169/286] coday fix

---
 .../elec_elec/orbital_dependent/test_generic_jastrow_orbital.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 48131a2e..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
@@ -59,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."""

From fb224ed8b6d3ec206c9da1396fb6d3c977c4d4e5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 7 Jan 2025 15:41:47 +0100
Subject: [PATCH 170/286] bug fix

---
 docs/example/backflow/backflow.py                     |  2 +-
 docs/notebooks/create_backflow.ipynb                  |  2 +-
 .../orbitals/backflow/kernels/backflow_kernel_base.py | 11 +++++++----
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/docs/example/backflow/backflow.py b/docs/example/backflow/backflow.py
index abc4de98..d557ef25 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -19,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))
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index a6f3f11f..43f8b237 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -71,7 +71,7 @@
     "        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",
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 4a838bc3..3f36892b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -96,7 +96,7 @@ 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):
@@ -109,8 +109,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

From 91b64867210290bd65a3214ac2a859ef69eba96d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 7 Jan 2025 16:32:03 +0100
Subject: [PATCH 171/286] log backflow

---
 .../orbitals/backflow/backflow_transformation.py            | 5 +++++
 qmctorch/wavefunction/slater_jastrow.py                     | 6 ++++++
 2 files changed, 11 insertions(+)

diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 0bc8f650..c933c726 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -518,3 +518,8 @@ def _backflow_second_derivative_od(self, pos):
         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/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index edde7ae7..8894c856 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -112,8 +112,11 @@ def init_atomic_orb(self, backflow):
         """Initialize the atomic orbital layer."""
         self.backflow = backflow
         if self.backflow is None:
+            self.use_backflow = False
             self.ao = AtomicOrbitals(self.mol, self.cuda)
         else:
+            self.use_backflow = True
+            self.backflow_type = self.backflow.__repr__()
             self.ao = AtomicOrbitalsBackFlow(self.mol, self.backflow, self.cuda)
 
         if self.cuda:
@@ -563,6 +566,9 @@ def log_data(self):
         """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)

From d7469c7d7d7b895cb310696bda19c31b0b969291 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 7 Jan 2025 16:45:32 +0100
Subject: [PATCH 172/286] unfreeze hvd

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 61d0f27e..1041e56d 100644
--- a/setup.py
+++ b/setup.py
@@ -47,7 +47,7 @@
                       'plams', 'mpi4py'],
 
     extras_require={
-        'hpc': ['horovod==0.27.0'],
+        'hpc': ['horovod'],
         'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert','jupyter'],
         'test': ['pytest', 'pytest-runner',
                  'coverage', 'coveralls', 'pycodestyle'],

From ff69333d4e76f1f94df738175fee88e97c2adc6d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 7 Jan 2025 16:53:31 +0100
Subject: [PATCH 173/286] remove hvd install as it crashes

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5b9b8aa7..f39eb6d8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -36,7 +36,7 @@ jobs:
         conda install -c anaconda gxx_linux-64
 
     - name: Install the package
-      run: python -m pip install .[test,hpc,doc]
+      run: python -m pip install .[test,doc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 

From 9f449a405cd01f8595b1081cf6b6c0e978857dd2 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 7 Jan 2025 17:19:23 +0100
Subject: [PATCH 174/286] unfreeze torch

---
 .github/workflows/build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f39eb6d8..dd670290 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -31,12 +31,12 @@ jobs:
     - name: Install conda packages
       run: |
         conda install -c anaconda cmake
-        conda install rdkit mpi4py h5py pytorch==2.0.0 torchvision==0.15.0 cpuonly -c pytorch -c conda-forge
+        conda install rdkit mpi4py h5py pytorch==2.1.1 cpuonly -c pytorch -c conda-forge
         conda install -c conda-forge libstdcxx-ng
         conda install -c anaconda gxx_linux-64
 
     - name: Install the package
-      run: python -m pip install .[test,doc]
+      run: python -m pip install .[test,hpc,doc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 

From ff879d48196d29ab4b7ebbc25cedf1dd53bc3468 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 8 Jan 2025 13:20:20 +0100
Subject: [PATCH 175/286] remove hvd as it still crashes

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index dd670290..32c46dd8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -36,7 +36,7 @@ jobs:
         conda install -c anaconda gxx_linux-64
 
     - name: Install the package
-      run: python -m pip install .[test,hpc,doc]
+      run: python -m pip install .[test,doc]
       env:
         CONDA_PREFIX: /usr/share/miniconda
 

From d64e8dca427de528a603406aee239d348eb15134 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 14 Jan 2025 14:05:28 +0100
Subject: [PATCH 176/286] orb withou projector

---
 .../wavefunction/pooling/orbital_projector.py | 30 +++++++++++-
 .../wavefunction/pooling/slater_pooling.py    | 49 ++++++++++++++-----
 qmctorch/wavefunction/slater_jastrow.py       | 48 +++++++++++-------
 3 files changed, 96 insertions(+), 31 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index a1c30ec1..63f63bfd 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -39,7 +39,7 @@ def get_projectors(self):
 
         return Pup.unsqueeze(1).to(self.device), Pdown.unsqueeze(1).to(self.device)
 
-    def split_orbitals(self, mat):
+    def split_orbitals_(self, mat):
         """Split the orbital  matrix in multiple slater matrices
 
         Args:
@@ -63,7 +63,35 @@ def split_orbitals(self, mat):
 
         return out_up, out_down
 
+    def split_orbitals(self, mat):
+        """Split the orbital  matrix in multiple slater matrices
+           This version does not store the projectors
+
+        Args:
+            mat (torch.tensor): matrix to split
+
+        Returns:
+            torch.tensor: all slater matrices
+        """
+        if mat.ndim == 3:
+            nbatch = mat.shape[0]
+            out_up = torch.zeros(0, nbatch, self.nup, self.nup)
+            out_down = torch.zeros(0, nbatch, self.ndown, self.ndown)
 
+        if mat.ndim == 4:
+            nbatch = mat.shape[1]
+            nop = mat.shape[0]
+            out_up = torch.zeros(0, nop, nbatch, self.nup, self.nup)
+            out_down = torch.zeros(0, nop, nbatch, self.ndown, self.ndown)
+        
+        for _, (cup, cdown) in enumerate(zip(self.configs[0], self.configs[1])):
+
+            # 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):
         """Select the occupied MOs of Slater determinant using masks
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 8ad51e01..ae02d85c 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -1,7 +1,7 @@
 import torch
 from torch import nn
 import operator as op
-
+from time import time
 from ...utils import bdet2, btrace
 from .orbital_configurations import get_excitation, get_unique_excitation
 from .orbital_projector import ExcitationMask, OrbitalProjector
@@ -39,6 +39,7 @@ def __init__(self, config_method, configs, mol, cuda=False):
         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(
@@ -132,7 +133,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
@@ -252,8 +253,12 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
         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)
+            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)
 
         elif self.config_method.startswith("cas("):
             op_vals = self.operator_explicit(mo, bop, op_squared)
@@ -327,7 +332,7 @@ def operator_explicit(self, mo, bkin, op_squared=False):
         Aup, Adown = self.orb_proj.split_orbitals(mo)
         Bup, Bdown = self.orb_proj.split_orbitals(bkin)
 
-        # check ifwe have 1 or multiple ops
+        # check if we have 1 or multiple ops
         multiple_op = Bup.ndim == 5
 
         # inverse of MO matrices
@@ -388,7 +393,7 @@ def operator_unique_single_double(self, mo, bop, op_squared):
             bkin ([type]): [description]
             op_squared (bool) return the trace of the square of the product
         """
-
+        t0 = time()
         nbatch = mo.shape[0]
 
         if not hasattr(self.exc_mask, "index_unique_single_up"):
@@ -407,8 +412,10 @@ def operator_unique_single_double(self, mo, bop, op_squared):
         Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
+        
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
+        
 
         # precompute invA @ B
         invAB_up = invAup @ bop[..., : self.nup, : self.nup]
@@ -450,8 +457,11 @@ def operator_unique_single_double(self, mo, bop, op_squared):
             invAdown @ bop_virt_down - invAdown @ bop_occ_down @ invAdown @ Avirt_down
         )
 
+        # print('     Prep : ', time() - t0)
+        
         # if we only want the normal value of the op and not its squared
         if not op_squared:
+            # t0 = time()
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             Mdown = Mdown.view(*Mdown.shape[:-2], -1)
@@ -478,7 +488,8 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-
+                # print('     Calc single : ', time() - t0)
+            # t0 = time()
             if do_double:
                 # spin up
                 op_dbl_up = self.op_multiexcitation(
@@ -503,12 +514,13 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-
+            # print('     Calc double : ', time() - t0)
             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:
+            # t0 = time()
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -545,8 +557,9 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-
+                # print('     Calc single: ', time() - t0)
             if do_double:
+                # t0 = time()
                 # spin up values
                 op_dbl_up = self.op_squared_multiexcitation(
                     op_ground_up,
@@ -572,7 +585,7 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-
+                # print('     Calc double: ', time() - t0)
             return op_out_up, op_out_down
 
     @staticmethod
@@ -622,20 +635,34 @@ def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
         """
 
         # get the values of the excitation matrix invA Abar
+        
         T = mat_exc.view(nbatch, -1)[:, index]
+        # print(T.shape, M.shape)
 
         # get the shapes of the size x size matrices
         _ext_shape = (*T.shape[:-1], -1, size, size)
         _m_shape = (*M.shape[:-1], -1, size, size)
 
         # computes the inverse of invA Abar
+        # t0 = time()
+        # print(T.view(_ext_shape).shape)
         T = torch.inverse(T.view(_ext_shape))
+        # print(T.shape)
+        # print('         Inverse T: ', time() - t0)
 
         # computes T @ M (after reshaping M as size x size matrices)
-        op_vals = T @ (M[..., index]).view(_m_shape)
+        # t0 = time()
+
+        m_tmp = M[..., index].view(_m_shape)
+        op_vals =  T @ m_tmp
+        # print(T.shape, m_tmp.shape)
+        # op_vals = T @ (M[..., index]).view(_m_shape)
+        # print('         Mat Mult: ', time() - t0)
 
         # compute the trace
+        # t0 = time()
         op_vals = btrace(op_vals)
+        # print('         Trace: ', time() - t0)
 
         # add the base term
         op_vals += baseterm
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 8894c856..f2454e61 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -6,6 +6,8 @@
 import operator
 import matplotlib.pyplot as plt
 
+from linetimer import CodeTimer
+
 from .. import log
 
 from .wf_base import WaveFunction
@@ -489,37 +491,45 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         Returns:
             torch.tensor: values of the kinetic energy at each sampling points
         """
+        silent_timer = False
 
         # get ao values
-        ao, dao, d2ao = self.ao(x, derivative=[0, 1, 2], sum_grad=False)
+        with CodeTimer('Get AOs', silent=silent_timer):
+            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)
-
+        with CodeTimer('Get MOs', silent=silent_timer):
+            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)
+        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) )
-        hess = self.pool.operator(mo, d2mo)
+        with CodeTimer('Get Hess', silent=silent_timer):
+            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)
+        with CodeTimer('Get Grad', silent=silent_timer):
+            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)
+        with CodeTimer('Get Grad2', silent=silent_timer):
+            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
+        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
@@ -542,6 +552,7 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
 
         # 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
@@ -549,7 +560,6 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
 
         # 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, sum_grad=True, pdf=False):

From c536004dc1b15a18369deda00c322e585c84e9be Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 14 Jan 2025 15:27:20 +0100
Subject: [PATCH 177/286] add linetimer install

---
 README.md                                       | 2 +-
 qmctorch/wavefunction/pooling/slater_pooling.py | 1 -
 qmctorch/wavefunction/slater_jastrow.py         | 2 +-
 setup.py                                        | 2 +-
 4 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index f6b5a2a3..13797f29 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 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)
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index ae02d85c..290aa656 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -412,7 +412,6 @@ def operator_unique_single_double(self, mo, bop, op_squared):
         Aocc_down = mo[:, self.nup :, : self.ndown]
 
         # inverse of the
-        
         invAup = torch.inverse(Aocc_up)
         invAdown = torch.inverse(Aocc_down)
         
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index f2454e61..812dcb49 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -491,7 +491,7 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         Returns:
             torch.tensor: values of the kinetic energy at each sampling points
         """
-        silent_timer = False
+        silent_timer = True
 
         # get ao values
         with CodeTimer('Get AOs', silent=silent_timer):
diff --git a/setup.py b/setup.py
index 1041e56d..8d96847d 100644
--- a/setup.py
+++ b/setup.py
@@ -42,7 +42,7 @@
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
                       'scipy', 'tqdm', 'torch',
-                      'plams', 'pints',
+                      'plams', 'pints', 'linetimer',
                       'pyscf', 'mendeleev', 'twiggy',
                       'plams', 'mpi4py'],
 

From 683f2d522121695e3b873019486cbdd53ef130f1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 14 Jan 2025 15:38:09 +0100
Subject: [PATCH 178/286] remove unused code

---
 .github/workflows/build.yml                   |  5 ++-
 .../wavefunction/pooling/orbital_projector.py | 43 -------------------
 2 files changed, 4 insertions(+), 44 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 32c46dd8..2bd91994 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,9 @@
 name: build
 
-on: [push]
+on: [push, pull_request]
+  branches:
+    - master
+    - development
 
 jobs:
   build:
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 63f63bfd..07f2cbb1 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -20,49 +20,6 @@ def __init__(self, configs, mol, cuda=False):
         if cuda:
             self.device = torch.device("cuda")
 
-    def get_projectors(self):
-        """Get the projectors of the conf in the CI expansion
-
-        Returns:
-            torch.tensor, torch.tensor : projectors
-        """
-
-        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.0
-
-            for _id, imo in enumerate(cdown):
-                Pdown[ic][imo, _id] = 1.0
-
-        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
-
-        Args:
-            mat (torch.tensor): matrix to split
-
-        Returns:
-            torch.tensor: all slater matrices
-        """
-        if not hasattr(self, "Pup"):
-            self.Pup, self.Pdown = self.get_projectors()
-
-        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)
-
-        else:
-            # case for single operator
-            out_up = mat[..., : self.nup, :] @ self.Pup
-            out_down = mat[..., self.nup :, :] @ self.Pdown
-
-        return out_up, out_down
-
     def split_orbitals(self, mat):
         """Split the orbital  matrix in multiple slater matrices
            This version does not store the projectors

From bba6e44a8c25d3b4be4641a08092afda0a6a321b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 14 Jan 2025 15:40:24 +0100
Subject: [PATCH 179/286] fix wfl

---
 .github/workflows/build.yml | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 2bd91994..66845c08 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,9 +1,14 @@
 name: build
 
-on: [push, pull_request]
-  branches:
-    - master
-    - development
+on:
+  push:
+    branches:
+      - master
+      - development
+  pull_request:
+    branches:
+      - master
+      - development
 
 jobs:
   build:

From 3896558f865e14a4edf8d947bdddcd33400e0cc1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 15 Jan 2025 09:46:37 +0100
Subject: [PATCH 180/286] precompute inverse of MO

---
 .../wavefunction/pooling/slater_pooling.py    | 99 ++++++++++---------
 qmctorch/wavefunction/slater_jastrow.py       | 10 +-
 2 files changed, 57 insertions(+), 52 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 290aa656..a9b651ed 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -236,14 +236,15 @@ def det_unique_single_double(self, input):
 
         return det_out_up, det_out_down
 
-    def operator(self, mo, bop, op=op.add, op_squared=False):
+    def operator(self, mo, bop, op=op.add, op_squared=False, inv_mo=None):
         """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)
             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
@@ -258,7 +259,7 @@ def operator(self, mo, bop, op=op.add, op_squared=False):
             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)
+                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)
@@ -272,27 +273,22 @@ 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, bop, op_squared=False, inv_mo=None):
         """Computes the values of any operator on gs only
 
         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
+            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
 
         Returns:
             torch.tensor: 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]
@@ -366,34 +362,36 @@ def operator_explicit(self, mo, bkin, op_squared=False):
 
         return (op_val_up, op_val_down)
 
-    def operator_single_double(self, mo, bop, op_squared=False):
+    def operator_single_double(self, mo, bop, op_squared=False, inv_mo=None):
         """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
+            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
 
         Returns:
             torch.tensor: kinetic energy values
         """
 
-        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]],
         )
 
-    def operator_unique_single_double(self, mo, bop, op_squared):
+    def operator_unique_single_double(self, mo, bop, op_squared, inv_mo):
         """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
+            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
+
         """
-        t0 = time()
         nbatch = mo.shape[0]
 
         if not hasattr(self.exc_mask, "index_unique_single_up"):
@@ -405,15 +403,11 @@ def operator_unique_single_double(self, mo, bop, op_squared):
         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
@@ -456,11 +450,10 @@ def operator_unique_single_double(self, mo, bop, op_squared):
             invAdown @ bop_virt_down - invAdown @ bop_occ_down @ invAdown @ Avirt_down
         )
 
-        # print('     Prep : ', time() - t0)
         
         # if we only want the normal value of the op and not its squared
         if not op_squared:
-            # t0 = time()
+
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             Mdown = Mdown.view(*Mdown.shape[:-2], -1)
@@ -487,8 +480,7 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-                # print('     Calc single : ', time() - t0)
-            # t0 = time()
+
             if do_double:
                 # spin up
                 op_dbl_up = self.op_multiexcitation(
@@ -513,13 +505,13 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-            # print('     Calc double : ', time() - t0)
+
             return op_out_up, op_out_down
 
         # if we want the squre of the operator
         # typically trace(ABAB)
         else:
-            # t0 = time()
+
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -556,9 +548,9 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-                # print('     Calc single: ', time() - t0)
+
             if do_double:
-                # t0 = time()
+                
                 # spin up values
                 op_dbl_up = self.op_squared_multiexcitation(
                     op_ground_up,
@@ -584,7 +576,7 @@ def operator_unique_single_double(self, mo, bop, op_squared):
                 # 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)
-                # print('     Calc double: ', time() - t0)
+
             return op_out_up, op_out_down
 
     @staticmethod
@@ -634,34 +626,22 @@ def op_multiexcitation(baseterm, mat_exc, M, index, size, nbatch):
         """
 
         # get the values of the excitation matrix invA Abar
-        
         T = mat_exc.view(nbatch, -1)[:, index]
-        # print(T.shape, M.shape)
 
         # get the shapes of the size x size matrices
         _ext_shape = (*T.shape[:-1], -1, size, size)
         _m_shape = (*M.shape[:-1], -1, size, size)
 
         # computes the inverse of invA Abar
-        # t0 = time()
-        # print(T.view(_ext_shape).shape)
         T = torch.inverse(T.view(_ext_shape))
-        # print(T.shape)
-        # print('         Inverse T: ', time() - t0)
 
         # computes T @ M (after reshaping M as size x size matrices)
-        # t0 = time()
-
+        # THIS IS SURPRSINGLY THE COMPUTATIONAL BOTTLENECK
         m_tmp = M[..., index].view(_m_shape)
         op_vals =  T @ m_tmp
-        # print(T.shape, m_tmp.shape)
-        # op_vals = T @ (M[..., index]).view(_m_shape)
-        # print('         Mat Mult: ', time() - t0)
 
         # compute the trace
-        # t0 = time()
         op_vals = btrace(op_vals)
-        # print('         Trace: ', time() - t0)
 
         # add the base term
         op_vals += baseterm
@@ -750,3 +730,24 @@ def op_squared_multiexcitation(baseterm, mat_exc, M, Y, index, size, nbatch):
         op_vals += baseterm
 
         return op_vals
+    
+
+    def compute_inverse_occupied_mo_matrix(self, mo: torch.tensor) -> tuple:
+        """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_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 812dcb49..19dfff73 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -502,6 +502,10 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
             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):
@@ -510,15 +514,15 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
 
         # 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)
+            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)
+            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)
+            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):

From 9bf0105cb2884557c5cf8c92774b56659a3cf815 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 15 Jan 2025 17:07:46 +0100
Subject: [PATCH 181/286] use unique configs for explicit dets and ops

---
 .../wavefunction/pooling/orbital_projector.py | 22 ++++++++++++++++---
 .../wavefunction/pooling/slater_pooling.py    | 14 +++++++-----
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 07f2cbb1..769280c5 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -16,16 +16,26 @@ def __init__(self, configs, mol, cuda=False):
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
+        self.unique_configs, self.index_unique_configs = self.get_unique_configs()
         self.device = torch.device("cpu")
         if cuda:
             self.device = torch.device("cuda")
 
-    def split_orbitals(self, mat):
+    def get_unique_configs(self):
+        """Get the unique configurations
+        """
+        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)
+        return (configs_up, configs_down), (index_unique_confs_up, index_unique_confs_down)
+
+
+    def split_orbitals(self, mat, unique_configs=False):
         """Split the orbital  matrix in multiple slater matrices
            This version does not store the projectors
 
         Args:
             mat (torch.tensor): matrix to split
+            unique_confgs (bool, optional): compute only the slater matrices of the unique conf if True (Defaulta False)
 
         Returns:
             torch.tensor: all slater matrices
@@ -41,8 +51,14 @@ def split_orbitals(self, mat):
             out_up = torch.zeros(0, nop, nbatch, self.nup, self.nup)
             out_down = torch.zeros(0, nop, nbatch, self.ndown, self.ndown)
         
-        for _, (cup, cdown) in enumerate(zip(self.configs[0], self.configs[1])):
-
+        if unique_configs :
+            configs_up, configs_down = self.unique_configs
+            
+        else:
+            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)
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index a9b651ed..61aaec70 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -77,7 +77,7 @@ def get_slater_matrices(self, input):
         Returns:
             (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):
         """Computes the values of the determinants from the slater matrices
@@ -88,9 +88,10 @@ 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
@@ -325,8 +326,8 @@ def operator_explicit(self, mo, bkin, op_squared=False):
         """
 
         # 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 if we have 1 or multiple ops
         multiple_op = Bup.ndim == 5
@@ -360,7 +361,8 @@ 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)
+        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, bop, op_squared=False, inv_mo=None):
         """Computes the value of any operator on gs + single + double

From f8a6f0b77ba6c6b8113513d361093ec52a97ce7b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 16 Jan 2025 12:00:32 +0100
Subject: [PATCH 182/286] push tensor to device

---
 qmctorch/wavefunction/pooling/orbital_configurations.py | 2 +-
 qmctorch/wavefunction/pooling/orbital_projector.py      | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index c89489b6..8061b290 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -10,7 +10,7 @@ def __init__(self, mol):
         self.norb = mol.basis.nmo
 
     def get_configs(self, configs):
-        """Get the configuratio in the CI expansion
+        """Get the configurations in the CI expansion
 
         Args:
             configs (str): name of the configs we want
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 769280c5..24195566 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -42,14 +42,14 @@ def split_orbitals(self, mat, unique_configs=False):
         """
         if mat.ndim == 3:
             nbatch = mat.shape[0]
-            out_up = torch.zeros(0, nbatch, self.nup, self.nup)
-            out_down = torch.zeros(0, nbatch, self.ndown, self.ndown)
+            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:
             nbatch = mat.shape[1]
             nop = mat.shape[0]
-            out_up = torch.zeros(0, nop, nbatch, self.nup, self.nup)
-            out_down = torch.zeros(0, nop, nbatch, self.ndown, self.ndown)
+            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

From 27d35aac0019edaabe8d8edfe1de7776fbd23497 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 16 Jan 2025 12:19:44 +0100
Subject: [PATCH 183/286] push tensor to device

---
 qmctorch/wavefunction/pooling/orbital_projector.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 24195566..0ceb07be 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -26,7 +26,8 @@ def get_unique_configs(self):
         """
         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)
-        return (configs_up, configs_down), (index_unique_confs_up, index_unique_confs_down)
+
+        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))
 
 
     def split_orbitals(self, mat, unique_configs=False):

From b5a0e8e237308c2bb8c985614eed697e7916c8e0 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 16 Jan 2025 12:24:34 +0100
Subject: [PATCH 184/286] push tensor to device

---
 qmctorch/wavefunction/pooling/orbital_projector.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 0ceb07be..481040e9 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -16,11 +16,11 @@ def __init__(self, configs, mol, cuda=False):
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
-        self.unique_configs, self.index_unique_configs = self.get_unique_configs()
+        
         self.device = torch.device("cpu")
         if cuda:
             self.device = torch.device("cuda")
-
+        self.unique_configs, self.index_unique_configs = self.get_unique_configs()
     def get_unique_configs(self):
         """Get the unique configurations
         """

From 8bf837c24b7f82c0cb6c9d6c428f23e326789e7f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 16 Jan 2025 14:35:37 +0100
Subject: [PATCH 185/286] hdf5 dump tensor to cpu

---
 qmctorch/utils/hdf5_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index 513ac231..eb38cea3 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -315,7 +315,7 @@ def insert_tuple(obj, parent_grp, obj_name):
         obj_name {str} -- name of the object
     """
     # fix for type torch.Tensor
-    obj = [o.numpy() if isinstance(o, torch.Tensor) else o for o in obj]
+    obj = [o.cpu().numpy() if isinstance(o, torch.Tensor) else o for o in obj]
     insert_list(list(obj), parent_grp, obj_name)
 
 

From e2b75be94b6b407c0c06a2d87e4b9a8cb28d34c6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 17 Jan 2025 17:47:00 +0100
Subject: [PATCH 186/286] do not register backflow twice

---
 qmctorch/wavefunction/slater_jastrow.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 19dfff73..fed2f936 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -112,14 +112,14 @@ def __init__(
 
     def init_atomic_orb(self, backflow):
         """Initialize the atomic orbital layer."""
-        self.backflow = backflow
-        if self.backflow is None:
+        # 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 = self.backflow.__repr__()
-            self.ao = AtomicOrbitalsBackFlow(self.mol, self.backflow, self.cuda)
+            self.backflow_type = backflow.__repr__()
+            self.ao = AtomicOrbitalsBackFlow(self.mol, backflow, self.cuda)
 
         if self.cuda:
             self.ao = self.ao.to(self.device)
@@ -708,7 +708,7 @@ def sto(x, norm, alpha):
         return self.__class__(
             new_mol,
             self.jastrow,
-            backflow=self.backflow,
+            backflow=self.ao.backflow_trans,
             configs=self.configs_method,
             kinetic=self.kinetic_method,
             cuda=self.cuda,

From 95bc6da461ef25a06b43a01fa9246ca904b14edf Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 17 Jan 2025 17:54:25 +0100
Subject: [PATCH 187/286] log init sampling

---
 qmctorch/solver/solver.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index bda0cf8d..57850e8e 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -253,7 +253,6 @@ def run(
             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")
@@ -276,6 +275,8 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
             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)
@@ -296,6 +297,8 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
         # chkpt
         self.chkpt_every = chkpt_every
 
+        log.info("  done in %1.2f sec." % (time() - tstart))
+
     def save_data(self, hdf5_group):
         """Save the data to hdf5.
 

From 67601069bdd1df1e03192ce35bfd9a0da7a4d859 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 17 Jan 2025 18:16:13 +0100
Subject: [PATCH 188/286] regisger backflow in AO for consistency

---
 qmctorch/wavefunction/orbitals/atomic_orbitals.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index 99929c5d..8729aeb9 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -92,6 +92,9 @@ def __init__(self, mol, cuda=False):
             with torch.no_grad():
                 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")
         if self.cuda:

From 67a3eeaa7005a353066a52d56b4388cccaa8e17b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 20 Jan 2025 09:31:32 +0100
Subject: [PATCH 189/286] test batched single point and opt

---
 tests/solver/test_base_solver.py | 35 +++++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 6e97354c..6611f02c 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,5 +1,5 @@
 import unittest
-
+import numpy as np
 
 class BaseTestSolvers:
     class BaseTestSolverMolecule(unittest.TestCase):
@@ -14,26 +14,37 @@ def setUp(self):
             self.expected_variance = None
 
         def test1_single_point(self):
-            # sample and compute observables
-            obs = self.solver.single_point()
-            _, _ = obs.energy, obs.variance
-
-            # if self.expected_energy is not None:
-            #     assert(
-            #         np.any(np.isclose(e.data.item(), np.array(self.expected_energy))))
-
-            # if self.expected_variance is not None:
-            #     assert(
-            #         np.any(np.isclose(v.data.item(), np.array(self.expected_variance))))
+            """
+            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)

From 39c6be678ba419de5531a559869e314a73110e65 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 20 Jan 2025 10:12:43 +0100
Subject: [PATCH 190/286] force explicit dets

---
 qmctorch/wavefunction/pooling/slater_pooling.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 61aaec70..dd48ae3c 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -65,6 +65,8 @@ def forward(self, input):
         if self.config_method.startswith("cas("):
             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):

From 26bca750c2f7dc4ae699ce350bf21829c2a3cb66 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 14:22:00 +0100
Subject: [PATCH 191/286] freeze backflow

---
 qmctorch/solver/solver.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 57850e8e..83e39839 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -139,8 +139,12 @@ def freeze_parameters(self, freeze):
                     for param in self.wf.jastrow.parameters():
                         param.requires_grad = False
 
+                elif name.lower() == "backflow":
+                    for param in self.wf.backflow.parameters():
+                        param.requires_grad = False
+
                 else:
-                    opt_freeze = ["ci", "mo", "ao", "jastrow"]
+                    opt_freeze = ["ci", "mo", "ao", "jastrow", "backflow"]
                     raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
     def save_sampling_parameters(self):

From cf75c7b77ca5b3cf11618aec1b27627549d68fce Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 15:06:26 +0100
Subject: [PATCH 192/286] othogonalize mo mixer

---
 qmctorch/solver/solver.py               | 2 +-
 qmctorch/wavefunction/slater_jastrow.py | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 83e39839..85023578 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -140,7 +140,7 @@ def freeze_parameters(self, freeze):
                         param.requires_grad = False
 
                 elif name.lower() == "backflow":
-                    for param in self.wf.backflow.parameters():
+                    for param in self.wf.ao.backflow_trans.parameters():
                         param.requires_grad = False
 
                 else:
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index fed2f936..c6b3d7c1 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -3,6 +3,7 @@
 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
 
@@ -149,6 +150,9 @@ def init_mo_mixer(self):
         # init the weight to idenity matrix
         self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
 
+        # orthogonalize it
+        self.mo = orthogonal(self.mo)
+
         # put on the card if needed
         if self.cuda:
             self.mo.to(self.device)

From cb3ab499842dfe97483941279ed91ae18fe680c4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 15:37:01 +0100
Subject: [PATCH 193/286] dont ortho

---
 qmctorch/wavefunction/slater_jastrow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index c6b3d7c1..294ce4d4 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -151,7 +151,7 @@ def init_mo_mixer(self):
         self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
 
         # orthogonalize it
-        self.mo = orthogonal(self.mo)
+        # self.mo = orthogonal(self.mo)
 
         # put on the card if needed
         if self.cuda:

From 9812249692cc7a41f43642b887bd628f3a633e29 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 16:18:59 +0100
Subject: [PATCH 194/286] init weight of inverse transform

---
 .../orbitals/backflow/kernels/backflow_kernel_inverse.py      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 1b562d13..efb392fc 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -4,7 +4,7 @@
 
 
 class BackFlowKernelInverse(BackFlowKernelBase):
-    def __init__(self, mol, cuda=False):
+    def __init__(self, mol, cuda=False, weight=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
@@ -17,7 +17,7 @@ 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):
         """Computes the backflow kernel:

From c9abaa07bd335e1c497bf4fa3a282c4e50b36fbd Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 16:35:54 +0100
Subject: [PATCH 195/286] register param

---
 .../orbitals/backflow/kernels/backflow_kernel_inverse.py     | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index efb392fc..a670ba8a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -1,5 +1,7 @@
 import torch
 from torch import nn
+
+from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
@@ -18,7 +20,8 @@ def __init__(self, mol, cuda=False, weight=0.0):
         """
         super().__init__(mol, cuda)
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
-
+        register_extra_attributes(self, ["weight"])
+        
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
 

From bdc1b489ee308bd79b62f6d9e1f009567942bae8 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 23 Jan 2025 17:29:28 +0100
Subject: [PATCH 196/286] dont register bf weight

---
 .../orbitals/backflow/kernels/backflow_kernel_inverse.py       | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index a670ba8a..4dc62f28 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -20,8 +20,7 @@ def __init__(self, mol, cuda=False, weight=0.0):
         """
         super().__init__(mol, cuda)
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
-        register_extra_attributes(self, ["weight"])
-        
+
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:
 

From 23c9e31fa7d4222f812c15f63928f47a8004ebb4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Jan 2025 09:41:51 +0100
Subject: [PATCH 197/286] change ortho mo from loss to wf

---
 qmctorch/solver/solver.py               |  3 ++-
 qmctorch/wavefunction/slater_jastrow.py | 20 ++++++++++++++++----
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 85023578..ae3f2225 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -89,7 +89,8 @@ def configure(  # pylint: disable=too-many-arguments
             self.loss.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
-        if ortho_mo is not None:
+        if ortho_mo is True:
+            log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
             self.ortho_mo = ortho_mo
             self.ortho_loss = OrthoReg()
 
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 294ce4d4..44b77845 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -32,6 +32,7 @@ def __init__(
         kinetic="jacobi",
         cuda=False,
         include_all_mo=True,
+        orthogonalize_mo=False
     ):
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
@@ -60,6 +61,7 @@ def __init__(
             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
@@ -92,7 +94,7 @@ def __init__(
         self.init_molecular_orb(include_all_mo)
 
         # init the mo mixer layer
-        self.init_mo_mixer()
+        self.init_mo_mixer(orthogonalize_mo)
 
         # initialize the slater det calculator
         self.init_slater_det_calculator()
@@ -141,8 +143,17 @@ def init_molecular_orb(self, include_all_mo):
         if self.cuda:
             self.mo_scf.to(self.device)
 
-    def init_mo_mixer(self):
-        """Init the mo mixer layer"""
+    def init_mo_mixer(self, orthogonalize_mo):
+        """
+        Initialize the molecular orbital mixing layer.
+
+        Parameters
+        ----------
+        orthogonalize_mo : bool
+            whether to orthogonalize the mo mixer layer
+
+        """
+        self.orthogonalize_mo = orthogonalize_mo
 
         # mo mixer layer
         self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
@@ -151,7 +162,8 @@ def init_mo_mixer(self):
         self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
 
         # orthogonalize it
-        # self.mo = orthogonal(self.mo)
+        if self.orthogonalize_mo:
+            self.mo = orthogonal(self.mo)
 
         # put on the card if needed
         if self.cuda:

From dfd65f563908490720ac003aa2209743e36614e1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 28 Jan 2025 09:57:42 +0100
Subject: [PATCH 198/286] fix ortho_mo declaration bug

---
 qmctorch/solver/solver.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index ae3f2225..e77ac5cf 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -89,9 +89,9 @@ def configure(  # pylint: disable=too-many-arguments
             self.loss.use_weight = self.resampling_options.resample_every > 1
 
         # orthogonalization penalty for the MO coeffs
-        if ortho_mo is True:
+        self.ortho_mo = ortho_mo
+        if self.ortho_mo is True:
             log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
-            self.ortho_mo = ortho_mo
             self.ortho_loss = OrthoReg()
 
     def set_params_requires_grad(self, wf_params=True, geo_params=False):

From 84fe0af8ffa11b0b1377b19a5678e36944000fe4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 29 Jan 2025 15:00:11 +0100
Subject: [PATCH 199/286] changed log to hdf5

---
 qmctorch/solver/solver_base.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index eaec12b4..b365d7f1 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -142,12 +142,14 @@ def track_observable(self, obs_name):
 
         for k in obs_name:
             if k == "parameters":
-                for key, p in zip(self.wf.state_dict().keys(), self.wf.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()):
+                # 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", [])
 

From 2d4902bc3b8dae0e476ba7dfcb41f0a1d7cb893d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Jan 2025 19:12:38 +0100
Subject: [PATCH 200/286] add tag to out and h5

---
 qmctorch/__init__.py           | 5 +++--
 qmctorch/__tag__.py            | 4 ++++
 qmctorch/__version__.py        | 6 ++++++
 qmctorch/solver/solver_base.py | 4 +++-
 qmctorch/utils/hdf5_utils.py   | 1 -
 5 files changed, 16 insertions(+), 4 deletions(-)
 create mode 100644 qmctorch/__tag__.py

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 9589dc8c..818e5e02 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
-
 from .__version__ import __version__
-
+from .__version__ import git_describe_tag
 __author__ = "Nicolas Renaud"
 __email__ = "n.renaud@esciencecenter.nl"
 
@@ -17,3 +16,5 @@
 log.info(r" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
 log.info(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
 log.info(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
+log.info("")
+log.info("{0}", git_describe_tag)
diff --git a/qmctorch/__tag__.py b/qmctorch/__tag__.py
new file mode 100644
index 00000000..bb842e7f
--- /dev/null
+++ b/qmctorch/__tag__.py
@@ -0,0 +1,4 @@
+import subprocess
+import os
+cwd = os.path.dirname(os.path.abspath(__file__))
+gittag = subprocess.check_output(["git", "describe", "--tags"], cwd=cwd).decode("utf-8").strip("\n")
\ No newline at end of file
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index f9aa3e11..9af73623 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1,7 @@
+import subprocess
+import os
+
 __version__ = "0.3.2"
+
+cwd = os.path.dirname(os.path.abspath(__file__))
+git_describe_tag = subprocess.check_output(["git", "describe", "--tags"], cwd=cwd).decode("utf-8").strip("\n")
\ No newline at end of file
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index b365d7f1..a94a8f13 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -6,7 +6,7 @@
 
 from .. import log
 from ..utils import add_group_attr, dump_to_hdf5
-
+from ..__tag__ import gittag
 
 class SolverBase:
     def __init__(  # pylint: disable=too-many-arguments
@@ -29,6 +29,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.scheduler = scheduler
         self.cuda = False
         self.device = torch.device("cpu")
+        self.gittag = gittag
 
         # member defined in the child and or method
         self.dataloader = None
@@ -131,6 +132,7 @@ def track_observable(self, obs_name):
 
         # reset the Namesapce
         self.observable = SimpleNamespace()
+        self.observable.qmctorch_tag = gittag
 
         # add the energy of the sytem
         if "energy" not in obs_name:
diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index eb38cea3..cb7a46a7 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -6,7 +6,6 @@
 
 from .. import log
 
-
 def print_insert_error(obj, obj_name):
     print(obj_name, obj)
     log.critical(

From 1c029a8b12da8ff44c15c185fb1cf3317983e0b5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Jan 2025 19:25:11 +0100
Subject: [PATCH 201/286] fix version

---
 qmctorch/__version__.py | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 9af73623..5ebd7d19 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1,7 +1 @@
-import subprocess
-import os
-
-__version__ = "0.3.2"
-
-cwd = os.path.dirname(os.path.abspath(__file__))
-git_describe_tag = subprocess.check_output(["git", "describe", "--tags"], cwd=cwd).decode("utf-8").strip("\n")
\ No newline at end of file
+__version__ = "0.3.2"
\ No newline at end of file

From 611d72ba8b9698cf37a9e5176771a9b349f5785e Mon Sep 17 00:00:00 2001
From: Nicolas Renaud <nicolas.gm.renaud@gmail.com>
Date: Thu, 30 Jan 2025 21:50:21 +0100
Subject: [PATCH 202/286] Update __init__.py

---
 qmctorch/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 818e5e02..476157dd 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
 from .__version__ import __version__
-from .__version__ import git_describe_tag
+from .__tag__ import gittag
 __author__ = "Nicolas Renaud"
 __email__ = "n.renaud@esciencecenter.nl"
 
@@ -17,4 +17,4 @@
 log.info(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
 log.info(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
 log.info("")
-log.info("{0}", git_describe_tag)
+log.info("{0}", gittag)

From 4b0789e6746f53fa96c3bf48ee9f950b65d8045f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 31 Jan 2025 08:35:41 +0100
Subject: [PATCH 203/286] fix provenance tag

---
 qmctorch/utils/__init__.py   |  1 +
 qmctorch/utils/provenance.py | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 qmctorch/utils/provenance.py

diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index dbfbfd64..a81cdea5 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -1,6 +1,7 @@
 """Utils module API."""
 
 from .algebra_utils import bdet2, bproj, btrace
+from .provenance import get_git_tag
 from .hdf5_utils import (
     add_group_attr,
     dump_to_hdf5,
diff --git a/qmctorch/utils/provenance.py b/qmctorch/utils/provenance.py
new file mode 100644
index 00000000..02caf492
--- /dev/null
+++ b/qmctorch/utils/provenance.py
@@ -0,0 +1,21 @@
+import subprocess
+import os
+from ..__version__ import __version__
+
+
+def get_git_tag():
+    """
+    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

From 70599a43fa5e538c4541b2d182547244cd5251ad Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 31 Jan 2025 08:35:47 +0100
Subject: [PATCH 204/286] fix provenance tag

---
 qmctorch/__init__.py           | 5 +++--
 qmctorch/__tag__.py            | 4 ----
 qmctorch/solver/solver_base.py | 8 ++++----
 3 files changed, 7 insertions(+), 10 deletions(-)
 delete mode 100644 qmctorch/__tag__.py

diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 476157dd..a701e0b7 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
 from .__version__ import __version__
-from .__tag__ import gittag
+
+
 __author__ = "Nicolas Renaud"
 __email__ = "n.renaud@esciencecenter.nl"
 
@@ -17,4 +18,4 @@
 log.info(r"/ /_/ / / /|_/ / /__  / / / _ \/ __/ __/ _ \ ")
 log.info(r"\___\_\/_/  /_/\___/ /_/  \___/_/  \__/_//_/ ")
 log.info("")
-log.info("{0}", gittag)
+log.info("{0}", __version__)
diff --git a/qmctorch/__tag__.py b/qmctorch/__tag__.py
deleted file mode 100644
index bb842e7f..00000000
--- a/qmctorch/__tag__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-import subprocess
-import os
-cwd = os.path.dirname(os.path.abspath(__file__))
-gittag = subprocess.check_output(["git", "describe", "--tags"], cwd=cwd).decode("utf-8").strip("\n")
\ No newline at end of file
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index a94a8f13..efce536a 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -6,7 +6,7 @@
 
 from .. import log
 from ..utils import add_group_attr, dump_to_hdf5
-from ..__tag__ import gittag
+from ..utils import get_git_tag
 
 class SolverBase:
     def __init__(  # pylint: disable=too-many-arguments
@@ -29,7 +29,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.scheduler = scheduler
         self.cuda = False
         self.device = torch.device("cpu")
-        self.gittag = gittag
+        self.qmctorch_version = get_git_tag()
 
         # member defined in the child and or method
         self.dataloader = None
@@ -132,8 +132,8 @@ def track_observable(self, obs_name):
 
         # reset the Namesapce
         self.observable = SimpleNamespace()
-        self.observable.qmctorch_tag = gittag
-
+        self.observable.qmctorch_version = self.qmctorch_version
+        
         # add the energy of the sytem
         if "energy" not in obs_name:
             obs_name += ["energy"]

From c60c0eac482b4078e9f2a4a3a28756b346fe9c40 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 3 Feb 2025 18:42:44 +0100
Subject: [PATCH 205/286] fix adf calculator

---
 qmctorch/scf/calculator/adf.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 91a0ec23..c5d7674d 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -91,11 +91,13 @@ def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
         bohr2angs = 0.529177
-        scale = 1.0
-        if self.units == "bohr":
-            scale = bohr2angs
+        # scale = 1.0
+        # if self.units == "bohr":
+        #     scale = bohr2angs
+        scale = bohr2angs
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(scale * np.array(xyz))
+            print(at, xyz)
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
         return mol
 

From 3e885700073538332bb3b1f897604cb3870f2116 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Feb 2025 09:03:32 +0100
Subject: [PATCH 206/286] clean up atom coord fix

---
 qmctorch/scf/calculator/adf.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index c5d7674d..3d430710 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -90,14 +90,9 @@ def init_plams(self):
     def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
-        bohr2angs = 0.529177
-        # scale = 1.0
-        # if self.units == "bohr":
-        #     scale = bohr2angs
-        scale = bohr2angs
+        bohr2angs = 0.529177 # the coordinate are always in bohr
         for at, xyz in zip(self.atoms, self.atom_coords):
-            xyz = list(scale * np.array(xyz))
-            print(at, xyz)
+            xyz = list(bohr2angs * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
         return mol
 

From dd1b2884d7d82c190a214127e7636c7458e54d37 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Feb 2025 10:56:37 +0100
Subject: [PATCH 207/286] tf32 disbled

---
 qmctorch/utils/torch_utils.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index b6b1e3dc..e392f343 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -8,12 +8,16 @@
 def set_torch_double_precision():
     """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():
     """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)
 
 

From 8e5bac6a869feeea9ebe7c8da9e5055ab157c6cb Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Feb 2025 15:17:47 +0100
Subject: [PATCH 208/286] added rbf backflow kernel

---
 .../backflow/kernels/backflow_kernel_rbf.py   | 136 ++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py

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..7c47b24b
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -0,0 +1,136 @@
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from .....utils import register_extra_attributes
+from .backflow_kernel_base import BackFlowKernelBase
+
+class RBFKernel(BackFlowKernelBase):
+
+    def __init__(self, mol, num_rbf, cuda):
+
+        """
+        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):
+        
+        '''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):
+        '''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):
+        '''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):
+        '''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):
+        """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):
+        """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
+    
+    

From 5beab8ab88d4ba88a885f7aaacdd3234a77b24e7 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Feb 2025 15:42:33 +0100
Subject: [PATCH 209/286] added rbf test

---
 .../orbitals/backflow/kernels/__init__.py     |   2 +
 .../backflow/kernels/backflow_kernel_rbf.py   |   4 +-
 .../test_backflow_transformation_rbf_pyscf.py | 119 ++++++++++++++++++
 3 files changed, 123 insertions(+), 2 deletions(-)
 create mode 100644 tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py

diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index 7f51395b..f31d7b67 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -4,6 +4,7 @@
 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
 
 __all__ = [
     "BackFlowKernelBase",
@@ -12,4 +13,5 @@
     "BackFlowKernelInverse",
     "BackFlowKernelPowerSum",
     "BackFlowKernelSquare",
+    "BackFlowKernelRBF",
 ]
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
index 7c47b24b..ac0e6d6d 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -5,9 +5,9 @@
 from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
-class RBFKernel(BackFlowKernelBase):
+class BackFlowKernelRBF(BackFlowKernelBase):
 
-    def __init__(self, mol, num_rbf, cuda):
+    def __init__(self, mol, cuda = False, num_rbf=10):
 
         """
         Initialize the RBF kernel
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..7c8bb775
--- /dev/null
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -0,0 +1,119 @@
+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
+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):
+    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
+
+    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)
+
+
+if __name__ == "__main__":
+    unittest.main()

From c59ff8c1e3a9acd01f0277ab634f19c07b07424c Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 6 Feb 2025 14:17:47 +0100
Subject: [PATCH 210/286] started calc

---
 qmctorch/ase/__init__.py |   0
 qmctorch/ase/ase.py      | 133 +++++++++++++++++++++++++++++++++++++++
 setup.py                 |   2 +-
 3 files changed, 134 insertions(+), 1 deletion(-)
 create mode 100644 qmctorch/ase/__init__.py
 create mode 100644 qmctorch/ase/ase.py

diff --git a/qmctorch/ase/__init__.py b/qmctorch/ase/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
new file mode 100644
index 00000000..8bbe15be
--- /dev/null
+++ b/qmctorch/ase/ase.py
@@ -0,0 +1,133 @@
+from ase.calculators.calculator import Calculator, all_changes
+import torch
+from torch import optim
+
+from ..utils import set_torch_double_precision
+from ..scf.molecule import Molecule
+from ..wavefunction.slater_jastrow import SlaterJastrow
+from ..wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
+from ..solver import Solver
+from ..sampler import Metropolis
+
+class QMCTorchCalculator(Calculator):
+
+    implemented_properties = ["energy", "forces"]
+
+    def __init__(self,
+                 restart=None,
+                 *,
+                 labels=None,
+                 atoms=None,
+                 solver=None,
+                 **kwargs):
+        
+        Calculator.__init__(self, restart=restart, labels=labels, atoms=atoms)
+        self.use_cuda = torch.cuda.is_available()
+        set_torch_double_precision()
+
+    def set(self, **kwargs):
+        raise NotImplementedError("Not done yet")
+
+    def set_atoms(self, atoms):
+        """
+        Set atoms object.
+
+        Parameters
+        ----------
+        atoms : ASE Atoms object
+            The atoms object to be set.
+        """
+        self.atoms = atoms
+
+
+    def reset(self):
+        """
+        Reset the calculator.
+        """
+        self.atoms = None
+        self.reset_results()
+
+    def reset_results(self):
+        self.results = {}
+
+    def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
+        """_summary_
+
+        Args:
+            atoms (_type_, optional): _description_. Defaults to None.
+            properties (list, optional): _description_. Defaults to ['energy'].
+            system_changes (_type_, optional): _description_. Defaults to None.
+        """
+
+        if any([p not in properties for p in self.implemented_properties]):
+            raise ValueError('property not recognized')
+        
+        for p in properties:
+            if p is 'energy':
+                self.calculate_energy(atoms=atoms)
+            if p is 'froces':
+                self.calculate_forces(atoms=atoms)
+
+
+    def set_solver(self, atoms):
+        """_summary_
+
+        Args:
+            atoms (_type_): _description_
+        """
+        xyz_filename = './mol.xyz'
+        atoms.write(xyz_filename)
+
+        mol = Molecule(atom=xyz_filename, unit='angs', calculator='adf', basis='dzp')
+        jastrow = JastrowFactor(mol, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_gpu)
+        configs =  'single_double(2,2)'
+
+        wf = SlaterJastrow(mol, kinetic='jacobi',
+                    configs=configs,
+                    backflow=None,
+                    jastrow=jastrow,
+                    orthogonalize_mo=True,
+                    cuda=self.use_gpu)
+        
+        sampler = Metropolis(nwalkers=4000, nstep=2000, nelec=wf.nelec, ntherm=-1, ndecor=1,
+                    step_size=0.05, init=mol.domain('atomic'), cuda=self.use_gpu)
+
+        lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
+                {'params': wf.ao.parameters(), 'lr': 1E-2},
+                {'params': wf.mo.parameters(), 'lr': 1E-2},
+                {'params': wf.fc.parameters(), 'lr': 1E-2}]
+        opt = optim.Adam(lr_dict, lr=1E-2)
+
+
+        solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)
+        solver.set_params_requires_grad(wf_params=True, geo_params=False)
+
+        solver.configure(track=['local_energy', 'parameters'], freeze=[],
+                loss='energy', grad='manual',
+                ortho_mo=False, clip_loss=False,
+                resampling={'mode': 'update','resample_every':1, 'nstep_update':50, 'ntherm_update':-1}
+                )
+        return solver
+
+    def calculate_energy(self, atoms=None):
+        """_summary_
+
+        Args:
+            atoms (_type_, optional): _description_. Defaults to None.
+        """
+        Calculator.calculate(self, atoms)
+        atoms = self.atoms
+        solver = self.set_solver(atoms)
+        solver.run(5, tqdm=True)
+
+    def calculate_forces(self, atoms, d=0.001):
+        """_summary_
+
+        Args:
+            atoms (_type_, optional): _description_. Defaults to None.
+            d (float, optional): _description_. Defaults to 0.001.
+        """
+        Calculator.calculate(self, atoms)
+        atoms = self.atoms
+        solver = self.set_solver(atoms)
+        solver.run(5, tqdm=True)
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 8d96847d..35dc95b4 100644
--- a/setup.py
+++ b/setup.py
@@ -44,7 +44,7 @@
                       'scipy', 'tqdm', 'torch',
                       'plams', 'pints', 'linetimer',
                       'pyscf', 'mendeleev', 'twiggy',
-                      'plams', 'mpi4py'],
+                      'plams', 'mpi4py', 'ase'],
 
     extras_require={
         'hpc': ['horovod'],

From 395d0318b5eff5b7ebfe992a5fa062b3464420ea Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 7 Feb 2025 11:30:12 +0100
Subject: [PATCH 211/286] set up

---
 qmctorch/ase/__init__.py |   1 +
 qmctorch/ase/ase.py      | 186 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 183 insertions(+), 4 deletions(-)

diff --git a/qmctorch/ase/__init__.py b/qmctorch/ase/__init__.py
index e69de29b..796a7a30 100644
--- a/qmctorch/ase/__init__.py
+++ b/qmctorch/ase/__init__.py
@@ -0,0 +1 @@
+from .ase import QMCTorchCalculator 
\ No newline at end of file
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 8bbe15be..3a14e2a7 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -1,4 +1,5 @@
 from ase.calculators.calculator import Calculator, all_changes
+from ase import Atoms
 import torch
 from torch import optim
 
@@ -18,7 +19,6 @@ def __init__(self,
                  *,
                  labels=None,
                  atoms=None,
-                 solver=None,
                  **kwargs):
         
         Calculator.__init__(self, restart=restart, labels=labels, atoms=atoms)
@@ -26,7 +26,185 @@ def __init__(self,
         set_torch_double_precision()
 
     def set(self, **kwargs):
-        raise NotImplementedError("Not done yet")
+        recpognized_options = ['molecule','wf','sampler','optimizer','solver']
+        for k, _ in kwargs.items():
+            if k.lower() not in recpognized_options:
+                raise ValueError("Unknown option %s" % k)
+            
+            if k.lower() == 'molecule':
+                self.set_molecule(kwargs[k])
+            if k.lower() == 'wf':
+                self.set_wf(kwargs[k])
+            if k.lower() == 'sampler':
+                self.set_sampler(kwargs[k])
+            if k.lower() == 'solver':
+                self.set_solver(kwargs[k])
+            if k.lower() == 'optimizer':
+                self.set_optimizer(kwargs[k])
+
+    def set_molecule(self, molecule):
+        """
+        Set molecule object.
+
+        Parameters
+        ----------
+        molecule : qmctorch.Molecule
+            The molecule object to be set. The atoms object will be set
+            accordingly.
+        """
+        self.molecule = molecule
+        if molecule is not None:
+            atom_names = ''.join(molecule.atoms)
+            self.set_atoms(Atoms(atom_names, positions=molecule.atom_coords))
+
+    def set_default_molecule(self):
+        """
+        Set a default molecule 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 'ase_molecule.xyz' and then loading this file into a Molecule
+        object.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        if self.atoms is None:
+            raise ValueError("Atoms object is not set")
+        filename = 'ase_molecule.xyz'
+        self.atoms.write(filename) 
+        self.molecule = Molecule(atom=filename, unit='angs', calculator='pyscf', basis='dzp')
+
+    def set_default_wf(self):
+        """
+        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.
+        """
+
+        if self.molecule is None:
+            raise ValueError("Molecule object is not set")
+        
+        configs =  'single_double(2,2)'
+        jastrow = JastrowFactor(self.molecule, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_gpu)
+        self.wf = SlaterJastrow(mol=self.molecule,
+                                kinetic='jacobi',
+                                configs=configs,
+                                backflow=None,
+                                jastrow=jastrow,
+                                orthogonalize_mo=True,
+                                cuda=self.use_gpu)
+        
+    def set_default_sampler(self):
+        """
+        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_gpu is True, the sampler will use the GPU.
+        """
+        if self.wf is None:
+            raise ValueError("Wave function object is not set")
+        
+        self.sampler = Metropolis(nwalkers=4000, nstep=2000, nelec=self.wf.nelec, ntherm=-1, ndecor=1,
+                    step_size=0.05, init=self.mol.domain('atomic'), cuda=self.use_gpu)
+        
+    def set_default_optimizer(self):
+        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_default_solver(self):
+        if self.wf is None:
+            self.set_default_wf()
+        
+        if self.sampler is None:
+            self.set_default_sampler()
+
+        if self.optimizer is None:
+            self.set_default_optimizer()
+        
+
+        self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.optimizer, scheduler=None)
+        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+
+        self.solver.configure(track=['local_energy', 'parameters'], freeze=[],
+                loss='energy', grad='manual',
+                ortho_mo=False, clip_loss=False,
+                resampling={'mode': 'update','resample_every':1, 'nstep_update':50, 'ntherm_update':-1}
+                )
+
+
+    def set_wf(self, wf):
+        """
+        Set the wave function object.
+
+        Parameters
+        ----------
+        wf : qmctorch.WaveFunction
+            The wave function object to be set.
+        """
+        self.wf = wf
+        self.set_molecule(self.wf.molecule)
+
+    def set_sampler(self, sampler):
+        """
+        Set the sampler object.
+
+        Parameters
+        ----------
+        sampler : qmctorch.Sampler
+            The sampler object to be set.
+        """
+        self.sampler = sampler
+
+    def set_optimizer(self, optimizer):
+        """
+        Set optimizer object.
+
+        Parameters
+        ----------
+        optimizer : torch.optim.Optimizer
+            The optimizer object to be set.
+        """
+        self.optimizer = optimizer
+
+    def set_solver(self, solver):
+        """
+        Set the solver object.
+
+        Parameters
+        ----------
+        solver : qmctorch.Solver
+            The solver object to be set.
+        """
+        self.solver = solver
+        self.set_wf(self.solver.wf)
+        self.set_sampler(self.solver.sampler)
+        self.set_optimizer(self.solver.optimizer)
+        
 
     def set_atoms(self, atoms):
         """
@@ -63,9 +241,9 @@ def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
             raise ValueError('property not recognized')
         
         for p in properties:
-            if p is 'energy':
+            if p == 'energy':
                 self.calculate_energy(atoms=atoms)
-            if p is 'froces':
+            if p == 'froces':
                 self.calculate_forces(atoms=atoms)
 
 

From e68a459a5877192fff58dc54dcdb50358de9a128 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 7 Feb 2025 13:45:27 +0100
Subject: [PATCH 212/286] add set up

---
 qmctorch/ase/ase.py | 135 ++++++++++++++++++++++++++------------------
 1 file changed, 81 insertions(+), 54 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 3a14e2a7..09cd95a9 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -80,6 +80,30 @@ def set_default_molecule(self):
         self.atoms.write(filename) 
         self.molecule = Molecule(atom=filename, unit='angs', calculator='pyscf', basis='dzp')
 
+    def update_molecule(self, atoms):
+        """
+        Update the molecule object based on the current atoms object.
+
+        Parameters
+        ----------
+        atoms : ase.Atoms
+            The atoms object to be used to update the molecule object.
+
+        Returns
+        -------
+        None
+        """
+        if self.molecule is None:
+            raise ValueError('Molecule object not set')
+        
+        self.atoms = atoms
+        filename = 'ase_molecule.xyz'
+        self.atoms.write(filename) 
+        self.molecule = Molecule(atom=filename, unit=self.molecule.unit, 
+                                 calculator=self.molecule.calculator, basis=self.molecule.basis_name,
+                                 scf=self.molecule.scf_level, charge=self.molecule.charge, spin=self.molecule.spin,
+                                 name=self.molecule.name)
+
     def set_default_wf(self):
         """
         Set the default wave function for the QMCTorchCalculator.
@@ -97,14 +121,33 @@ def set_default_wf(self):
             raise ValueError("Molecule object is not set")
         
         configs =  'single_double(2,2)'
-        jastrow = JastrowFactor(self.molecule, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_gpu)
+        jastrow = JastrowFactor(self.molecule, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_cuda)
         self.wf = SlaterJastrow(mol=self.molecule,
                                 kinetic='jacobi',
                                 configs=configs,
                                 backflow=None,
                                 jastrow=jastrow,
                                 orthogonalize_mo=True,
-                                cuda=self.use_gpu)
+                                cuda=self.use_cuda)
+        
+
+    def update_wf(self):
+        """
+        Updates the wave function using the current molecule and the
+        previously set wave function configuration parameters.
+
+        Raises:
+            ValueError: If the wave function object is not set yet.
+        """
+        if self.wf is None:
+            raise ValueError("Wave function object not set yet")
+        
+        self.wf(self.molecule, configs=self.wf.configs_method, 
+                kinetic=self.wf.kinetic_method,
+                backflow=None, jastrow=self.wf.jastrow,
+                orthogonalize_mo=self.wf.orthogonalize_mo,
+                cuda=self.use_cuda
+                )
         
     def set_default_sampler(self):
         """
@@ -119,13 +162,13 @@ def set_default_sampler(self):
         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_gpu is True, the sampler will use the GPU.
+        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.sampler = Metropolis(nwalkers=4000, nstep=2000, nelec=self.wf.nelec, ntherm=-1, ndecor=1,
-                    step_size=0.05, init=self.mol.domain('atomic'), cuda=self.use_gpu)
+                    step_size=0.05, init=self.mol.domain('atomic'), cuda=self.use_cuda)
         
     def set_default_optimizer(self):
         if self.wf is None:
@@ -137,6 +180,25 @@ def set_default_optimizer(self):
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
     def set_default_solver(self):
+        """
+        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.wf is None:
             self.set_default_wf()
         
@@ -192,19 +254,13 @@ def set_optimizer(self, optimizer):
         self.optimizer = optimizer
 
     def set_solver(self, solver):
-        """
-        Set the solver object.
+        """_summary_
 
-        Parameters
-        ----------
-        solver : qmctorch.Solver
-            The solver object to be set.
+        Args:
+            atoms (_type_): _description_
         """
         self.solver = solver
-        self.set_wf(self.solver.wf)
-        self.set_sampler(self.solver.sampler)
-        self.set_optimizer(self.solver.optimizer)
-        
+         
 
     def set_atoms(self, atoms):
         """
@@ -247,45 +303,6 @@ def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
                 self.calculate_forces(atoms=atoms)
 
 
-    def set_solver(self, atoms):
-        """_summary_
-
-        Args:
-            atoms (_type_): _description_
-        """
-        xyz_filename = './mol.xyz'
-        atoms.write(xyz_filename)
-
-        mol = Molecule(atom=xyz_filename, unit='angs', calculator='adf', basis='dzp')
-        jastrow = JastrowFactor(mol, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_gpu)
-        configs =  'single_double(2,2)'
-
-        wf = SlaterJastrow(mol, kinetic='jacobi',
-                    configs=configs,
-                    backflow=None,
-                    jastrow=jastrow,
-                    orthogonalize_mo=True,
-                    cuda=self.use_gpu)
-        
-        sampler = Metropolis(nwalkers=4000, nstep=2000, nelec=wf.nelec, ntherm=-1, ndecor=1,
-                    step_size=0.05, init=mol.domain('atomic'), cuda=self.use_gpu)
-
-        lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
-                {'params': wf.ao.parameters(), 'lr': 1E-2},
-                {'params': wf.mo.parameters(), 'lr': 1E-2},
-                {'params': wf.fc.parameters(), 'lr': 1E-2}]
-        opt = optim.Adam(lr_dict, lr=1E-2)
-
-
-        solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)
-        solver.set_params_requires_grad(wf_params=True, geo_params=False)
-
-        solver.configure(track=['local_energy', 'parameters'], freeze=[],
-                loss='energy', grad='manual',
-                ortho_mo=False, clip_loss=False,
-                resampling={'mode': 'update','resample_every':1, 'nstep_update':50, 'ntherm_update':-1}
-                )
-        return solver
 
     def calculate_energy(self, atoms=None):
         """_summary_
@@ -293,7 +310,17 @@ def calculate_energy(self, atoms=None):
         Args:
             atoms (_type_, optional): _description_. Defaults to None.
         """
-        Calculator.calculate(self, atoms)
+        if atoms is not None:
+            self.atoms = atoms
+            if self.molecule is None:
+                self.set_default_molecule()
+            else:
+                self.update_molecule()
+
+            if self.wf is None:
+                self.set_default_wf()
+            else:
+                self.update_wf()
         atoms = self.atoms
         solver = self.set_solver(atoms)
         solver.run(5, tqdm=True)

From a20b3efe2779a0f08a971efbb80687f30305a8c3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 7 Feb 2025 13:45:49 +0100
Subject: [PATCH 213/286] add set up

---
 qmctorch/ase/ase.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 09cd95a9..59b6bc6c 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -321,6 +321,7 @@ def calculate_energy(self, atoms=None):
                 self.set_default_wf()
             else:
                 self.update_wf()
+               
         atoms = self.atoms
         solver = self.set_solver(atoms)
         solver.run(5, tqdm=True)

From fa514fd26dc707b335547bdc4e162315ed6ec07e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 10 Feb 2025 14:34:56 +0100
Subject: [PATCH 214/286] calc works

---
 qmctorch/ase/ase.py | 279 ++++++++++++++++++--------------------------
 1 file changed, 112 insertions(+), 167 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 59b6bc6c..4d9d9def 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -2,9 +2,10 @@
 from ase import Atoms
 import torch
 from torch import optim
+from types import SimpleNamespace
 
 from ..utils import set_torch_double_precision
-from ..scf.molecule import Molecule
+from ..scf.molecule import Molecule as SCF
 from ..wavefunction.slater_jastrow import SlaterJastrow
 from ..wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from ..solver import Solver
@@ -25,39 +26,42 @@ def __init__(self,
         self.use_cuda = torch.cuda.is_available()
         set_torch_double_precision()
 
-    def set(self, **kwargs):
-        recpognized_options = ['molecule','wf','sampler','optimizer','solver']
-        for k, _ in kwargs.items():
-            if k.lower() not in recpognized_options:
-                raise ValueError("Unknown option %s" % k)
-            
-            if k.lower() == 'molecule':
-                self.set_molecule(kwargs[k])
-            if k.lower() == 'wf':
-                self.set_wf(kwargs[k])
-            if k.lower() == 'sampler':
-                self.set_sampler(kwargs[k])
-            if k.lower() == 'solver':
-                self.set_solver(kwargs[k])
-            if k.lower() == 'optimizer':
-                self.set_optimizer(kwargs[k])
-
-    def set_molecule(self, molecule):
-        """
-        Set molecule object.
-
-        Parameters
-        ----------
-        molecule : qmctorch.Molecule
-            The molecule object to be set. The atoms object will be set
-            accordingly.
-        """
-        self.molecule = molecule
-        if molecule is not None:
-            atom_names = ''.join(molecule.atoms)
-            self.set_atoms(Atoms(atom_names, positions=molecule.atom_coords))
-
-    def set_default_molecule(self):
+        # default options for the SCF
+        self.molecule = None
+        self.scf_options = SimpleNamespace(calculator='pyscf',
+                                           basis='dzp')
+        
+        # default options for the WF
+        self.wf = None
+        self.wf_options = SimpleNamespace(kinetic='jacobi',
+                                          configs='single_double(2,2)',
+                                          orthogonalize_mo=True,
+                                          include_all_mo=True,
+                                          cuda=self.use_cuda,
+                                          jastrow=SimpleNamespace(
+                                              kernel=PadeJastrowKernel,
+                                              kernel_kwargs={'w':1.00},
+                                          ),
+                                          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)
+        
+        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={'mode': 'update','resample_every':1, 
+                                                          'nstep_update':50, 'ntherm_update':-1},
+                                              niter=100, tqdm=False)
+
+    def run_scf(self):
         """
         Set a default molecule object. If the atoms object is not set, it raises
         a ValueError.
@@ -78,33 +82,12 @@ def set_default_molecule(self):
             raise ValueError("Atoms object is not set")
         filename = 'ase_molecule.xyz'
         self.atoms.write(filename) 
-        self.molecule = Molecule(atom=filename, unit='angs', calculator='pyscf', basis='dzp')
-
-    def update_molecule(self, atoms):
-        """
-        Update the molecule object based on the current atoms object.
-
-        Parameters
-        ----------
-        atoms : ase.Atoms
-            The atoms object to be used to update the molecule object.
-
-        Returns
-        -------
-        None
-        """
-        if self.molecule is None:
-            raise ValueError('Molecule object not set')
-        
-        self.atoms = atoms
-        filename = 'ase_molecule.xyz'
-        self.atoms.write(filename) 
-        self.molecule = Molecule(atom=filename, unit=self.molecule.unit, 
-                                 calculator=self.molecule.calculator, basis=self.molecule.basis_name,
-                                 scf=self.molecule.scf_level, charge=self.molecule.charge, spin=self.molecule.spin,
-                                 name=self.molecule.name)
+        self.molecule = SCF(atom=filename, 
+                                 unit='angs', 
+                                 calculator=self.scf_options.calculator, 
+                                 basis=self.scf_options.basis)
 
-    def set_default_wf(self):
+    def set_wf(self):
         """
         Set the default wave function for the QMCTorchCalculator.
 
@@ -120,36 +103,27 @@ def set_default_wf(self):
         if self.molecule is None:
             raise ValueError("Molecule object is not set")
         
-        configs =  'single_double(2,2)'
-        jastrow = JastrowFactor(self.molecule, PadeJastrowKernel, kernel_kwargs={'w':1.00}, cuda=self.use_cuda)
+        if self.wf_options.jastrow is not None:
+            jastrow = JastrowFactor(self.molecule, self.wf_options.jastrow.kernel, 
+                                    self.wf_options.jastrow.kernel_kwargs, cuda=self.use_cuda)
+        else:
+            jastrow = None
+
+        if self.wf_options.backflow is not None:
+            raise ValueError("Backflow is not supported yet")
+        else:
+            backflow = None
+
         self.wf = SlaterJastrow(mol=self.molecule,
-                                kinetic='jacobi',
-                                configs=configs,
-                                backflow=None,
+                                kinetic=self.wf_options.kinetic,
+                                configs=self.wf_options.configs,
+                                backflow=backflow,
                                 jastrow=jastrow,
-                                orthogonalize_mo=True,
+                                orthogonalize_mo=self.wf_options.orthogonalize_mo,
+                                include_all_mo=self.wf_options.include_all_mo,
                                 cuda=self.use_cuda)
         
-
-    def update_wf(self):
-        """
-        Updates the wave function using the current molecule and the
-        previously set wave function configuration parameters.
-
-        Raises:
-            ValueError: If the wave function object is not set yet.
-        """
-        if self.wf is None:
-            raise ValueError("Wave function object not set yet")
-        
-        self.wf(self.molecule, configs=self.wf.configs_method, 
-                kinetic=self.wf.kinetic_method,
-                backflow=None, jastrow=self.wf.jastrow,
-                orthogonalize_mo=self.wf.orthogonalize_mo,
-                cuda=self.use_cuda
-                )
-        
-    def set_default_sampler(self):
+    def set_sampler(self):
         """
         Set default sampler object.
 
@@ -167,8 +141,9 @@ def set_default_sampler(self):
         if self.wf is None:
             raise ValueError("Wave function object is not set")
         
-        self.sampler = Metropolis(nwalkers=4000, nstep=2000, nelec=self.wf.nelec, ntherm=-1, ndecor=1,
-                    step_size=0.05, init=self.mol.domain('atomic'), cuda=self.use_cuda)
+        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'), cuda=self.use_cuda)
         
     def set_default_optimizer(self):
         if self.wf is None:
@@ -179,7 +154,7 @@ def set_default_optimizer(self):
                 {'params': self.wf.fc.parameters(), 'lr': 1E-2}]
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
-    def set_default_solver(self):
+    def set_solver(self):
         """
         Set the default solver object for the QMCTorchCalculator.
 
@@ -199,69 +174,26 @@ def set_default_solver(self):
         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_default_wf()
+            self.set_wf()
         
         if self.sampler is None:
-            self.set_default_sampler()
+            self.set_sampler()
 
         if self.optimizer is None:
             self.set_default_optimizer()
         
 
         self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.optimizer, scheduler=None)
-        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
-
-        self.solver.configure(track=['local_energy', 'parameters'], freeze=[],
-                loss='energy', grad='manual',
-                ortho_mo=False, clip_loss=False,
-                resampling={'mode': 'update','resample_every':1, 'nstep_update':50, 'ntherm_update':-1}
+        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
                 )
 
-
-    def set_wf(self, wf):
-        """
-        Set the wave function object.
-
-        Parameters
-        ----------
-        wf : qmctorch.WaveFunction
-            The wave function object to be set.
-        """
-        self.wf = wf
-        self.set_molecule(self.wf.molecule)
-
-    def set_sampler(self, sampler):
-        """
-        Set the sampler object.
-
-        Parameters
-        ----------
-        sampler : qmctorch.Sampler
-            The sampler object to be set.
-        """
-        self.sampler = sampler
-
-    def set_optimizer(self, optimizer):
-        """
-        Set optimizer object.
-
-        Parameters
-        ----------
-        optimizer : torch.optim.Optimizer
-            The optimizer object to be set.
-        """
-        self.optimizer = optimizer
-
-    def set_solver(self, solver):
-        """_summary_
-
-        Args:
-            atoms (_type_): _description_
-        """
-        self.solver = solver
-         
-
     def set_atoms(self, atoms):
         """
         Set atoms object.
@@ -279,6 +211,10 @@ def reset(self):
         Reset the calculator.
         """
         self.atoms = None
+        self.wf = None
+        self.molecule = None
+        self.sampler = None
+        self.solver = None
         self.reset_results()
 
     def reset_results(self):
@@ -292,48 +228,57 @@ def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
             properties (list, optional): _description_. Defaults to ['energy'].
             system_changes (_type_, optional): _description_. Defaults to None.
         """
-
-        if any([p not in properties for p in self.implemented_properties]):
+        # if we don't have defined a solver yet
+        if self.solver is None:
+            if atoms is not None:
+                self.set_atoms(atoms)
+            self.set_solver()
+
+        # if we do have a solver in place
+        else:
+            if atoms is not None:
+                if (self.atoms.get_positions() !=  atoms.get_positions()).any():
+                    self.reset()
+                    self.set_atoms(atoms)
+                    self.set_solver()
+
+        if any([p not in self.implemented_properties for p in properties]):
             raise ValueError('property not recognized')
         
         for p in properties:
             if p == 'energy':
                 self.calculate_energy(atoms=atoms)
-            if p == 'froces':
+            if p == 'forces':
                 self.calculate_forces(atoms=atoms)
 
-
-
     def calculate_energy(self, atoms=None):
         """_summary_
 
         Args:
             atoms (_type_, optional): _description_. Defaults to None.
         """
-        if atoms is not None:
-            self.atoms = atoms
-            if self.molecule is None:
-                self.set_default_molecule()
-            else:
-                self.update_molecule()
-
-            if self.wf is None:
-                self.set_default_wf()
-            else:
-                self.update_wf()
-               
-        atoms = self.atoms
-        solver = self.set_solver(atoms)
-        solver.run(5, tqdm=True)
-
-    def calculate_forces(self, atoms, d=0.001):
+        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+        self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+        observable = self.solver.single_point()
+        self.results['energy'] = observable.energy
+
+    def calculate_forces(self, atoms=None,  d=0.001):
         """_summary_
 
         Args:
             atoms (_type_, optional): _description_. Defaults to None.
             d (float, optional): _description_. Defaults to 0.001.
         """
-        Calculator.calculate(self, atoms)
-        atoms = self.atoms
-        solver = self.set_solver(atoms)
-        solver.run(5, tqdm=True)
\ No newline at end of file
+        
+        # optimize the wave function
+        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+        self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+
+        # resample
+        observable = self.solver.single_point()
+
+        # compute the forces
+        self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
+        _, _ = self.solver.evaluate_gradient(observable.pos)
+        self.results['energy'] = observable.energy
+        self.results['forces'] = self.solver.wf.ao.atom_coords.grad
\ No newline at end of file

From 4ba024644186819707b39e5783abba5b25f0c50b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 10 Feb 2025 15:17:36 +0100
Subject: [PATCH 215/286] geo opt runs

---
 qmctorch/ase/ase.py | 127 ++++++++++++++++++++++++++++++++++++++------
 1 file changed, 112 insertions(+), 15 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 4d9d9def..1bb91d46 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -25,11 +25,13 @@ def __init__(self,
         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')
+                                           basis='dzp',
+                                           scf='hf')
         
         # default options for the WF
         self.wf = None
@@ -84,8 +86,9 @@ def run_scf(self):
         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)
+                                 basis=self.scf_options.basis, redo_scf=True)
 
     def set_wf(self):
         """
@@ -110,7 +113,7 @@ def set_wf(self):
             jastrow = None
 
         if self.wf_options.backflow is not None:
-            raise ValueError("Backflow is not supported yet")
+            raise ValueError("Backflow is not supported yet via the ASE calculator")
         else:
             backflow = None
 
@@ -215,18 +218,29 @@ def reset(self):
         self.molecule = None
         self.sampler = None
         self.solver = None
+        self.has_forces = False
         self.reset_results()
 
     def reset_results(self):
         self.results = {}
 
-    def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
-        """_summary_
+    def reset_solver(self, atoms=None):
+        """
+        Update the calculator.
 
-        Args:
-            atoms (_type_, optional): _description_. Defaults to None.
-            properties (list, optional): _description_. Defaults to ['energy'].
-            system_changes (_type_, optional): _description_. Defaults to None.
+        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.
+
+        Notes
+        -----
+        This method is typically called before calculating a quantity.
         """
         # if we don't have defined a solver yet
         if self.solver is None:
@@ -242,34 +256,61 @@ def calculate(self, atoms=None, properties=['energy'] ,system_changes=None):
                     self.set_atoms(atoms)
                     self.set_solver()
 
+    def calculate(self, atoms=None, properties=['energy']):
+        """_summary_
+
+        Args:
+            atoms (_type_, optional): _description_. Defaults to None.
+            properties (list, optional): _description_. Defaults to ['energy'].
+            system_changes (_type_, optional): _description_. Defaults to None.
+        """
+        # 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 == 'energy':
-                self.calculate_energy(atoms=atoms)
             if p == 'forces':
                 self.calculate_forces(atoms=atoms)
 
+            elif p == 'energy':
+                self.calculate_energy(atoms=atoms)
+
     def calculate_energy(self, atoms=None):
         """_summary_
 
         Args:
             atoms (_type_, optional): _description_. Defaults to None.
         """
+        # check if reset is necessary 
+        self.reset_solver(atoms=atoms)
+
+        # set wf param for opt
         self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+
+        # run the opt
         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=None,  d=0.001):
+    def calculate_forces(self, atoms=None):
         """_summary_
 
         Args:
             atoms (_type_, optional): _description_. Defaults to None.
             d (float, optional): _description_. Defaults to 0.001.
         """
-        
+        # check if reset is necessary
+        self.reset_solver(atoms=atoms)
+
         # optimize the wave function
         self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
         self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
@@ -280,5 +321,61 @@ def calculate_forces(self, atoms=None,  d=0.001):
         # compute the forces
         self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
         _, _ = self.solver.evaluate_gradient(observable.pos)
-        self.results['energy'] = observable.energy
-        self.results['forces'] = self.solver.wf.ao.atom_coords.grad
\ No newline at end of file
+
+        # store and output
+        self.results['energy'] = observable.energy.cpu().numpy()
+        self.results['forces'] = self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.has_forces = True
+        return self.results['forces']
+
+    def check_forces(self):
+        """
+        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=None):
+        """
+        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.
+        """
+        # if self.check_forces():
+        #     return self.results['forces']
+        # else:
+        return self.calculate_forces(atoms=atoms)
+        
+    def get_total_energy(self, atoms=None):
+        """
+        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.
+        """
+        if 'energy' in self.results:
+            return self.results['energy']
+        else:
+            return self.calculate_energy(atoms=atoms)
\ No newline at end of file

From e580c8241427fbb580be1dc58e5c4f5c9b798a89 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 10 Feb 2025 15:54:08 +0100
Subject: [PATCH 216/286] start every time

---
 qmctorch/ase/ase.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 1bb91d46..119409de 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -256,6 +256,10 @@ def reset_solver(self, atoms=None):
                     self.set_atoms(atoms)
                     self.set_solver()
 
+        self.reset()
+        self.set_atoms(atoms)
+        self.set_solver()
+
     def calculate(self, atoms=None, properties=['energy']):
         """_summary_
 
@@ -308,6 +312,7 @@ def calculate_forces(self, atoms=None):
             atoms (_type_, optional): _description_. Defaults to None.
             d (float, optional): _description_. Defaults to 0.001.
         """
+        print('+++++++++++++++++++COMPUTE FORCE++++++++++++++++++++++++++++')
         # check if reset is necessary
         self.reset_solver(atoms=atoms)
 
@@ -356,6 +361,8 @@ def get_forces(self, atoms=None):
         forces : array
             The total forces on the atoms.
         """
+        print(atoms.get_positions())
+        print(self.atoms.get_positions())
         # if self.check_forces():
         #     return self.results['forces']
         # else:

From 70e2174759a7a41e8f9a89890ef6743646edd725 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 11 Feb 2025 17:40:43 +0100
Subject: [PATCH 217/286] work on the calculator

---
 qmctorch/ase/__init__.py       |   2 +-
 qmctorch/ase/ase.py            | 240 ++++++++++++++++++++++++---------
 qmctorch/solver/solver.py      |   2 +-
 qmctorch/solver/solver_base.py |   1 +
 4 files changed, 183 insertions(+), 62 deletions(-)

diff --git a/qmctorch/ase/__init__.py b/qmctorch/ase/__init__.py
index 796a7a30..3ac3ba05 100644
--- a/qmctorch/ase/__init__.py
+++ b/qmctorch/ase/__init__.py
@@ -1 +1 @@
-from .ase import QMCTorchCalculator 
\ No newline at end of file
+from .ase import QMCTorch 
\ No newline at end of file
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 119409de..c37ed679 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -10,8 +10,9 @@
 from ..wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 from ..solver import Solver
 from ..sampler import Metropolis
+from .. import log
 
-class QMCTorchCalculator(Calculator):
+class QMCTorch(Calculator):
 
     implemented_properties = ["energy", "forces"]
 
@@ -22,6 +23,24 @@ def __init__(self,
                  atoms=None,
                  **kwargs):
         
+        """
+        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
+            Additional keyword arguments are passed to the
+            SCF, WF, Sampler, Optimizer and Solver objects.
+
+        """
         Calculator.__init__(self, restart=restart, labels=labels, atoms=atoms)
         self.use_cuda = torch.cuda.is_available()
         set_torch_double_precision()
@@ -44,7 +63,8 @@ def __init__(self,
                                               kernel=PadeJastrowKernel,
                                               kernel_kwargs={'w':1.00},
                                           ),
-                                          backflow=None)
+                                          backflow=None,
+                                          gto2sto=False)
 
 
         # default option for the sampler
@@ -59,17 +79,19 @@ def __init__(self,
         self.solver_options = SimpleNamespace(track=['local_energy', 'parameters'], freeze=[],
                                               loss='energy', grad='manual',
                                               ortho_mo=False, clip_loss=False,
-                                              resampling={'mode': 'update','resample_every':1, 
-                                                          'nstep_update':50, 'ntherm_update':-1},
+                                              resampling=SimpleNamespace(mode='update', 
+                                                                         resample_every=1, 
+                                                                         nstep_update=50, 
+                                                                         ntherm_update=-1),
                                               niter=100, tqdm=False)
 
     def run_scf(self):
         """
-        Set a default molecule object. If the atoms object is not set, it raises
+        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 'ase_molecule.xyz' and then loading this file into a Molecule
+        named '<name>.xyz' and then loading this file into a Molecule(SCF)
         object.
 
         Parameters
@@ -82,7 +104,7 @@ def run_scf(self):
         """
         if self.atoms is None:
             raise ValueError("Atoms object is not set")
-        filename = 'ase_molecule.xyz'
+        filename = self.atoms.get_chemical_formula() + '.xyz'
         self.atoms.write(filename) 
         self.molecule = SCF(atom=filename, 
                                  unit='angs', 
@@ -126,6 +148,11 @@ def set_wf(self):
                                 include_all_mo=self.wf_options.include_all_mo,
                                 cuda=self.use_cuda)
         
+        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):
         """
         Set default sampler object.
@@ -157,6 +184,36 @@ def set_default_optimizer(self):
                 {'params': self.wf.fc.parameters(), 'lr': 1E-2}]
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
+
+    def set_resampling_options(self):
+        """
+        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
+            # log.options(style="percent").info("Warning : Resampling option nstep_update adjusted to %d to match sampling size" \
+                                            #   %self.solver_options.resampling.nstep_update)
+
+        elif (self.sampler_options.ntherm == -1) and (self.solver_options.resampling.mode == 'update'):
+            if self.solver_options.resampling.ntherm_update != -1:
+                # log.options(style="percent").info(" Warning : Resampling option ntherm_update adjusted to -1 to match ntherm")
+                self.solver_options.resampling.ntherm_update = -1
+
     def set_solver(self):
         """
         Set the default solver object for the QMCTorchCalculator.
@@ -191,10 +248,13 @@ def set_solver(self):
         
 
         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
+                resampling=self.solver_options.resampling.__dict__
                 )
 
     def set_atoms(self, atoms):
@@ -211,7 +271,13 @@ def set_atoms(self, atoms):
 
     def reset(self):
         """
-        Reset the calculator.
+        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
@@ -222,9 +288,17 @@ def reset(self):
         self.reset_results()
 
     def reset_results(self):
+        """
+        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=None):
+    def reset_solver(self, atoms=None, force=True):
         """
         Update the calculator.
 
@@ -243,31 +317,54 @@ def reset_solver(self, atoms=None):
         This method is typically called before calculating a quantity.
         """
         # if we don't have defined a solver yet
-        if self.solver is None:
-            if atoms is not None:
-                self.set_atoms(atoms)
+        if not force:
+            if self.solver is None:
+                if atoms is not None:
+                    self.set_atoms(atoms)
+                self.reset()
+                self.set_solver()
+
+            # if we do have a solver in place
+            else:
+                if atoms is not None:
+                    if (self.atoms.get_positions() !=  atoms.get_positions()).any():
+                        self.reset()
+                        self.set_atoms(atoms)
+                        self.set_solver()
+        else:
+            self.reset()
+            self.set_atoms(atoms)
             self.set_solver()
 
-        # if we do have a solver in place
-        else:
-            if atoms is not None:
-                if (self.atoms.get_positions() !=  atoms.get_positions()).any():
-                    self.reset()
-                    self.set_atoms(atoms)
-                    self.set_solver()
+    def calculate(self, atoms=None, properties=['energy'], system_changes=None):
+        """
+        Calculate specified properties for the given atomic configuration.
 
-        self.reset()
-        self.set_atoms(atoms)
-        self.set_solver()
+        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.
 
-    def calculate(self, atoms=None, properties=['energy']):
-        """_summary_
+        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'].
+
+        Raises
+        ------
+        ValueError
+            If a requested property is not recognized or not implemented.
 
-        Args:
-            atoms (_type_, optional): _description_. Defaults to None.
-            properties (list, optional): _description_. Defaults to ['energy'].
-            system_changes (_type_, optional): _description_. Defaults to None.
+        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)
 
@@ -278,25 +375,39 @@ def calculate(self, atoms=None, properties=['energy']):
         # compute
         for p in properties:
             if p == 'forces':
-                self.calculate_forces(atoms=atoms)
+                self._calculate_forces(atoms=atoms)
 
             elif p == 'energy':
-                self.calculate_energy(atoms=atoms)
-
-    def calculate_energy(self, atoms=None):
-        """_summary_
+                self._calculate_energy(atoms=atoms)
 
-        Args:
-            atoms (_type_, optional): _description_. Defaults to None.
-        """
+    def _calculate_energy(self, atoms=None):
         # check if reset is necessary 
-        self.reset_solver(atoms=atoms)
+        """
+        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.
 
-        # set wf param for opt
-        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+        Returns
+        -------
+        energy : float
+            The computed energy.
 
-        # run the opt
-        self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+        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.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
 
         # compute the energy 
         observable = self.solver.single_point()
@@ -305,20 +416,31 @@ def calculate_energy(self, atoms=None):
         self.results['energy'] = observable.energy
         return self.results['energy']
 
-    def calculate_forces(self, atoms=None):
-        """_summary_
+    def _calculate_forces(self, atoms=None):
 
-        Args:
-            atoms (_type_, optional): _description_. Defaults to None.
-            d (float, optional): _description_. Defaults to 0.001.
-        """
-        print('+++++++++++++++++++COMPUTE FORCE++++++++++++++++++++++++++++')
         # check if reset is necessary
-        self.reset_solver(atoms=atoms)
+        """
+        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
-        self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
-        self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
+        if self.solver_options.niter > 0:
+            self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
+            self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
 
         # resample
         observable = self.solver.single_point()
@@ -329,7 +451,7 @@ def calculate_forces(self, atoms=None):
 
         # store and output
         self.results['energy'] = observable.energy.cpu().numpy()
-        self.results['forces'] = self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.results['forces'] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
         self.has_forces = True
         return self.results['forces']
 
@@ -361,12 +483,10 @@ def get_forces(self, atoms=None):
         forces : array
             The total forces on the atoms.
         """
-        print(atoms.get_positions())
-        print(self.atoms.get_positions())
-        # if self.check_forces():
-        #     return self.results['forces']
-        # else:
-        return self.calculate_forces(atoms=atoms)
+        if self.check_forces():
+            return self.results['forces']
+        else:
+            return self.calculate(atoms=atoms, properties=['forces'])
         
     def get_total_energy(self, atoms=None):
         """
@@ -385,4 +505,4 @@ def get_total_energy(self, atoms=None):
         if 'energy' in self.results:
             return self.results['energy']
         else:
-            return self.calculate_energy(atoms=atoms)
\ No newline at end of file
+            return self.calculate(atoms=atoms, properties=['energy'])
\ No newline at end of file
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index e77ac5cf..b90285a1 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -437,7 +437,7 @@ def evaluate_grad_manual(self, lpos):
             # evaluate the prefactor of the grads
             weight = eloc.clone()
             weight -= torch.mean(eloc)
-            weight /= psi
+            weight /= psi.clone()
             weight *= 2.0
             weight *= norm
 
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index efce536a..d829409d 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -350,6 +350,7 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
                 "  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(

From 2dd6c4859c0eb8ab64779568e66b2f8371358e25 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 12 Feb 2025 13:44:10 +0100
Subject: [PATCH 218/286] validate options

---
 qmctorch/ase/ase.py       | 48 ++++++++++++++++++++++++++++++------
 qmctorch/solver/solver.py | 52 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+), 8 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index c37ed679..1b214d08 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -52,6 +52,7 @@ def __init__(self,
                                            basis='dzp',
                                            scf='hf')
         
+        
         # default options for the WF
         self.wf = None
         self.wf_options = SimpleNamespace(kinetic='jacobi',
@@ -66,7 +67,6 @@ def __init__(self,
                                           backflow=None,
                                           gto2sto=False)
 
-
         # default option for the sampler
         self.sampler = None
         self.sampler_options = SimpleNamespace(nwalkers=4000, nstep=2000, 
@@ -84,6 +84,35 @@ def __init__(self,
                                                                          nstep_update=50, 
                                                                          ntherm_update=-1),
                                               niter=100, tqdm=False)
+        
+        # get the dict of the recognized options for validation
+        self.recognized_scf_options = list(self.scf_options.__dict__.keys())
+        self.recognized_wf_options = list(self.wf_options.__dict__.keys())  
+        self.recognized_jastrow_options = list(self.wf_options.jastrow.__dict__.keys())
+        self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
+        self.recognized_solver_options = list(self.solver_options.__dict__.keys())
+    @staticmethod
+    def validate_options(options, recognized_options, name=""):
+        """
+        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.
+        """
+        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):
         """
@@ -102,6 +131,8 @@ def run_scf(self):
         -------
         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'
@@ -129,6 +160,7 @@ def set_wf(self):
             raise ValueError("Molecule object is not set")
         
         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:
@@ -139,6 +171,7 @@ def set_wf(self):
         else:
             backflow = None
 
+        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,
@@ -170,7 +203,7 @@ def set_sampler(self):
         """
         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'), cuda=self.use_cuda)
@@ -206,12 +239,9 @@ def set_resampling_options(self):
         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
-            # log.options(style="percent").info("Warning : Resampling option nstep_update adjusted to %d to match sampling size" \
-                                            #   %self.solver_options.resampling.nstep_update)
 
         elif (self.sampler_options.ntherm == -1) and (self.solver_options.resampling.mode == 'update'):
             if self.solver_options.resampling.ntherm_update != -1:
-                # log.options(style="percent").info(" Warning : Resampling option ntherm_update adjusted to -1 to match ntherm")
                 self.solver_options.resampling.ntherm_update = -1
 
     def set_solver(self):
@@ -246,7 +276,7 @@ def set_solver(self):
         if self.optimizer is None:
             self.set_default_optimizer()
         
-
+        self.validate_options(self.solver_options, self.recognized_solver_options, 'Solver')
         self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.optimizer, scheduler=None)
 
         self.set_resampling_options()
@@ -445,9 +475,11 @@ def _calculate_forces(self, atoms=None):
         # resample
         observable = self.solver.single_point()
 
-        # compute the forces
+        # compute the forces 
+        # we use evaluate_grad_auto as evaluate_grad_manual is not
+        # valid for forces  
         self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
-        _, _ = self.solver.evaluate_gradient(observable.pos)
+        _, _ = self.solver.evaluate_grad_auto(observable.pos)
 
         # store and output
         self.results['energy'] = observable.energy.cpu().numpy()
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index b90285a1..bc7b33b0 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -406,6 +406,11 @@ def evaluate_grad_auto(self, lpos):
 
     def evaluate_grad_manual(self, lpos):
         """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]
@@ -448,6 +453,53 @@ def evaluate_grad_manual(self, lpos):
 
         else:
             raise ValueError("Manual gradient only for energy minimization")
+        
+    def evaluate_grad_manual_2(self, lpos):
+        """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_mean, eloc = self.loss(lpos, no_grad=no_grad_eloc)
+            psi = self.wf(lpos)
+            norm = 2.0 / len(psi)
+
+            weight1 = norm * eloc/psi.detach().clone()
+            weight2 = -norm * eloc_mean/psi.detach().clone()
+
+            psi.backward(weight1,retain_graph=True) 
+            psi.backward(weight2)
+
+            return torch.mean(eloc), eloc
+
+        else:
+            raise ValueError("Manual gradient only for energy minimization")
 
     def log_data_opt(self, nepoch, task):
         """Log data for the optimization."""

From 75cc320cff052f7a12442302b1f7a6270581cbea Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 12 Feb 2025 14:01:13 +0100
Subject: [PATCH 219/286] validate options

---
 qmctorch/ase/ase.py | 35 +++++++++++++++++++++++++----------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 1b214d08..76894918 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -8,6 +8,7 @@
 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 .. import log
@@ -51,6 +52,7 @@ def __init__(self,
         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
@@ -64,14 +66,24 @@ def __init__(self,
                                               kernel=PadeJastrowKernel,
                                               kernel_kwargs={'w':1.00},
                                           ),
-                                          backflow=None,
+                                          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)
+        self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
         
+        # optimizer .... 
         self.optimizer = None
 
         # default option for the solver
@@ -84,13 +96,9 @@ def __init__(self,
                                                                          nstep_update=50, 
                                                                          ntherm_update=-1),
                                               niter=100, tqdm=False)
-        
-        # get the dict of the recognized options for validation
-        self.recognized_scf_options = list(self.scf_options.__dict__.keys())
-        self.recognized_wf_options = list(self.wf_options.__dict__.keys())  
-        self.recognized_jastrow_options = list(self.wf_options.jastrow.__dict__.keys())
-        self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
         self.recognized_solver_options = list(self.solver_options.__dict__.keys())
+        self.recognized_resampling_options = list(self.solver_options.resampling.__dict__.keys())
+        
     @staticmethod
     def validate_options(options, recognized_options, name=""):
         """
@@ -155,10 +163,11 @@ def set_wf(self):
         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, 
@@ -166,11 +175,15 @@ def set_wf(self):
         else:
             jastrow = None
 
+        # check backflow and set it
         if self.wf_options.backflow is not None:
-            raise ValueError("Backflow is not supported yet via the ASE calculator")
+            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,
@@ -181,6 +194,7 @@ def set_wf(self):
                                 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")
@@ -277,8 +291,9 @@ def set_solver(self):
             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,

From b7552161788ae784614eaf78add177a1e0c89606 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 12 Feb 2025 15:45:17 +0100
Subject: [PATCH 220/286] added ase example

---
 docs/example/ase/h2.py | 88 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 docs/example/ase/h2.py

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
new file mode 100644
index 00000000..8c38220b
--- /dev/null
+++ b/docs/example/ase/h2.py
@@ -0,0 +1,88 @@
+from qmctorch.ase import QMCTorch     
+from ase import Atoms 
+from ase.optimize import GoodOldQuasiNewton
+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)
+
+d = 0.74
+h2 = Atoms('H2', positions=[(0, 0, -d/2), (0, 0, d/2)])
+
+h2.calc = QMCTorch()
+
+# SCF options
+h2.calc.scf_options.calculator = 'pyscf'
+h2.calc.scf_options.basis = 'sto-3g'
+
+# WF options
+h2.calc.wf_options.configs = 'ground_state'
+# h2.calc.wf_options.configs = 'single_double(2,2)'
+h2.calc.wf_options.orthogonalize_mo = False
+# h2.calc.wf_options.gto2sto = True
+h2.calc.wf_options.jastrow.kernel_kwargs = {'w':0.5}
+
+# sampler options
+h2.calc.sampler_options.nwalkers = 100
+h2.calc.sampler_options.nstep  = 5000
+h2.calc.sampler_options.step_size = 0.5
+h2.calc.sampler_options.ntherm = 4000
+h2.calc.sampler_options.ndecor = 10
+
+# solver options
+h2.calc.solver_options.freeze = []
+h2.calc.solver_options.niter = 0
+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
+
+# set solver
+h2.calc.set_solver()
+
+# sampling traj
+obs = h2.calc.solver.sampling_traj()
+plot_walkers_traj(obs.local_energy, walkers='mean')
+plot_correlation_coefficient(obs.local_energy)
+
+# sample
+# obs = h2.calc.solver.single_point()
+
+
+
+# h2.calc.solver.set_params_requires_grad(wf_params=False, geo_params=True)
+# h2.calc.solver.evaluate_grad_auto(obs.pos)
+# print(h2.calc.wf.ao.atom_coords.grad)
+
+# h2.calc.wf.zero_grad()
+# h2.calc.solver.evaluate_grad_manual(obs.pos)
+# print(h2.calc.wf.ao.atom_coords.grad)
+
+
+# h2.calc.wf.zero_grad()
+# h2.calc.solver.evaluate_grad_manual_2(obs.pos)
+# print(h2.calc.wf.ao.atom_coords.grad)
+
+
+
+# # set param
+# h2.calc.solver.set_params_requires_grad(wf_params=False, geo_params=True)
+
+# compute energy
+# h2.get_total_energy()
+
+# compute the forces
+# h2.get_forces()
+# print(h2.get_forces())
+
+# dyn = GoodOldQuasiNewton(h2, trajectory='traj.xyz')
+# dyn.run(fmax=0.05, steps=2)
+# write('final.xyz',h2)
+
+# h2.calc.solver.evaluate_grad_auto(obs.)
\ No newline at end of file

From 5995ed87ef8a7294758817b102324dcd93fed94f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 14 Feb 2025 19:12:16 +0100
Subject: [PATCH 221/286] fix bugs

---
 docs/example/ase/H2.xyz        |   4 +++
 docs/example/ase/final.xyz     |   4 +++
 docs/example/ase/h2.py         |  64 +++++++++------------------------
 docs/example/ase/traj.xyz      | Bin 0 -> 2850 bytes
 qmctorch/ase/ase.py            |  37 ++++++++++---------
 qmctorch/sampler/metropolis.py |   2 +-
 qmctorch/scf/calculator/adf.py |   4 ++-
 qmctorch/scf/molecule.py       |   3 +-
 qmctorch/solver/solver.py      |   4 +--
 qmctorch/utils/constants.py    |   2 ++
 10 files changed, 52 insertions(+), 72 deletions(-)
 create mode 100644 docs/example/ase/H2.xyz
 create mode 100644 docs/example/ase/final.xyz
 create mode 100644 docs/example/ase/traj.xyz
 create mode 100644 qmctorch/utils/constants.py

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/final.xyz b/docs/example/ase/final.xyz
new file mode 100644
index 00000000..af045fb9
--- /dev/null
+++ b/docs/example/ase/final.xyz
@@ -0,0 +1,4 @@
+2
+Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1601088283229546 pbc="F F F"
+H       -0.00030645       0.00039310      -0.36055667      -0.00204301       0.00262068      -0.07037781
+H       -0.00113510      -0.00025389       0.35945925      -0.00756733      -0.00169257       0.06306168
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 8c38220b..7bb2723f 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,6 +1,6 @@
 from qmctorch.ase import QMCTorch     
 from ase import Atoms 
-from ase.optimize import GoodOldQuasiNewton
+from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
 import torch
 import numpy as np
@@ -9,21 +9,21 @@
 torch.random.manual_seed(0)
 np.random.seed(0)
 
-d = 0.74
+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 = 'pyscf'
-h2.calc.scf_options.basis = 'sto-3g'
+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,2)'
+# h2.calc.wf_options.configs = 'ground_state'
+h2.calc.wf_options.configs = 'single_double(2,2)'
 h2.calc.wf_options.orthogonalize_mo = False
 # h2.calc.wf_options.gto2sto = True
-h2.calc.wf_options.jastrow.kernel_kwargs = {'w':0.5}
+h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
 
 # sampler options
 h2.calc.sampler_options.nwalkers = 100
@@ -34,7 +34,7 @@
 
 # solver options
 h2.calc.solver_options.freeze = []
-h2.calc.solver_options.niter = 0
+h2.calc.solver_options.niter = 10
 h2.calc.solver_options.tqdm = True
 h2.calc.solver_options.grad = 'manual'
 
@@ -43,46 +43,14 @@
 h2.calc.solver_options.resampling.resample_every = 1
 h2.calc.solver_options.resampling.ntherm_update = 100
 
-# set solver
+# Optimize the wave function
 h2.calc.set_solver()
+h2.get_total_energy()
 
-# sampling traj
-obs = h2.calc.solver.sampling_traj()
-plot_walkers_traj(obs.local_energy, walkers='mean')
-plot_correlation_coefficient(obs.local_energy)
+# change the number of steps
+h2.calc.solver_options.niter = 5
 
-# sample
-# obs = h2.calc.solver.single_point()
-
-
-
-# h2.calc.solver.set_params_requires_grad(wf_params=False, geo_params=True)
-# h2.calc.solver.evaluate_grad_auto(obs.pos)
-# print(h2.calc.wf.ao.atom_coords.grad)
-
-# h2.calc.wf.zero_grad()
-# h2.calc.solver.evaluate_grad_manual(obs.pos)
-# print(h2.calc.wf.ao.atom_coords.grad)
-
-
-# h2.calc.wf.zero_grad()
-# h2.calc.solver.evaluate_grad_manual_2(obs.pos)
-# print(h2.calc.wf.ao.atom_coords.grad)
-
-
-
-# # set param
-# h2.calc.solver.set_params_requires_grad(wf_params=False, geo_params=True)
-
-# compute energy
-# h2.get_total_energy()
-
-# compute the forces
-# h2.get_forces()
-# print(h2.get_forces())
-
-# dyn = GoodOldQuasiNewton(h2, trajectory='traj.xyz')
-# dyn.run(fmax=0.05, steps=2)
-# write('final.xyz',h2)
-
-# h2.calc.solver.evaluate_grad_auto(obs.)
\ No newline at end of file
+# use FIRE for the optimization
+dyn = FIRE(h2, trajectory='traj.xyz')
+dyn.run(fmax=0.005, steps=5)
+write('final.xyz',h2)
diff --git a/docs/example/ase/traj.xyz b/docs/example/ase/traj.xyz
new file mode 100644
index 0000000000000000000000000000000000000000..c2c43df80fd49ad0f274cc52a29b2f0679e6d72d
GIT binary patch
literal 2850
zcmdN@$WK!U&B=8PcGV3jO3X@4F3B&dR8U}MfB-fq{R1kn0?KDZqoG_ll?Dda_QM6B
z45+yMgJY{UHSS5+pR%OQ{A+ot{eRAH$K6>r?Qi&-l>X*l-F}9}o8GDKj^2NYIkMus
z$_D#uPz$S-%2JDpGxPJ5tP~7&6qFK+Q{xdLO2&Fd#(D-yK#7#p;^d;tf)a?*YNe9O
zf>fX$rF@`JZe~>?SOTaH%1<o<NxFFkxq>w3CRW53m!uXH0|gC${LH+P)S|M)9FV28
zKz>0|GLRXamY7qVs-u8R#R6sXN^_Hdj?@DxsaDEMNh~T#tOO~KHUh~4%`!6qT4HJz
z3pOghI1}U+Y|3>Mj6pima`F=)dd!W$dXiIfKu(E{HqZmQ4n_c#5)uHJmYkTAT$+;z
zjAp0<6LY}<Q<w{i`s56d{|gd}fTBP@g94yhDJL;0H3!7ZE6vFPIXX2jwJ06rCtX85
zLo)+I0}Bfy3u7ZAOH&gwkb{Bdq!Q&JLnDLO+S*!WWji+|CGDKA`&2)=R$Z?8ZMUy3
z+v#25wf!EIM{Y-66W;GJv1WVe{*U_<r}C%mF1SW=`r&}5p8`?>+|0ycn1#5RB{1F9
z*241f3noa$T)_&V71$y43=Rk_zy+a4N&F$OZp+L_1wn!RcS^R*mYXADpTEBJ*WZq7
z``>I`cCziD?*2D7ttK1H=h{E*Q(|grE9vQ%i@fw}Xly#{iVPD2Xqll51dwo7fQGw@
zeZ`NKzNxEW;cg2Jcd7ly>S9w;me4QU&5edz!C`1_4lX%Bp{}fa_WG(<rpLARZ{L=!
zb416`{$}LNe_L)|+dpgi)}RlkJ@(Jq8m$_vueN`qB~$W_vvdo0BSQm|VOC%p8G^Df
zsE!1ITZ#+?8KNfpg(fX@QafyEKl$<|uNdL$`?nZ!*nOE1wBO_eOHAEjgZ<&k0f~u>
e*GaA?$t-7#Oe}zz64bgFHcb;FQ&1MJtpxyx@Gt2A

literal 0
HcmV?d00001

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 76894918..c724c9e2 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -1,10 +1,12 @@
 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
@@ -361,25 +363,15 @@ def reset_solver(self, atoms=None, force=True):
         -----
         This method is typically called before calculating a quantity.
         """
-        # if we don't have defined a solver yet
-        if not force:
-            if self.solver is None:
-                if atoms is not None:
-                    self.set_atoms(atoms)
+        if atoms is not None:
+            # if any((self.atoms.get_positions() != np.array(self.molecule.atom_coords)).flatten().tolist()):
+            if not np.allclose(self.atoms.get_positions()*ANGS2BOHR, np.array(self.molecule.atom_coords)):
                 self.reset()
+                self.set_atoms(atoms)
                 self.set_solver()
-
-            # if we do have a solver in place
-            else:
-                if atoms is not None:
-                    if (self.atoms.get_positions() !=  atoms.get_positions()).any():
-                        self.reset()
-                        self.set_atoms(atoms)
-                        self.set_solver()
         else:
-            self.reset()
-            self.set_atoms(atoms)
-            self.set_solver()
+            if self.solver is None:
+                self.set_solver()
 
     def calculate(self, atoms=None, properties=['energy'], system_changes=None):
         """
@@ -449,6 +441,8 @@ def _calculate_energy(self, atoms=None):
         energy of the system. The result is stored in the calculator's results dictionary and
         returned.
         """
+        self.reset_solver(atoms=atoms)
+
         # optimize the wave function
         if self.solver_options.niter > 0:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
@@ -482,6 +476,9 @@ def _calculate_forces(self, atoms=None):
         -----
         The forces are computed by optimizing the wave function using the atomic positions as variational parameters.
         """
+
+        self.reset_solver(atoms=atoms)
+
         # optimize the wave function
         if self.solver_options.niter > 0:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
@@ -499,6 +496,8 @@ def _calculate_forces(self, atoms=None):
         # store and output
         self.results['energy'] = observable.energy.cpu().numpy()
         self.results['forces'] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.solver.wf.zero_grad()
+
         self.has_forces = True
         return self.results['forces']
 
@@ -533,8 +532,8 @@ def get_forces(self, atoms=None):
         if self.check_forces():
             return self.results['forces']
         else:
-            return self.calculate(atoms=atoms, properties=['forces'])
-        
+            return self._calculate_forces(atoms=atoms)
+    
     def get_total_energy(self, atoms=None):
         """
         Return the total energy.
@@ -552,4 +551,4 @@ def get_total_energy(self, atoms=None):
         if 'energy' in self.results:
             return self.results['energy']
         else:
-            return self.calculate(atoms=atoms, properties=['energy'])
\ No newline at end of file
+            return self._calculate_energy(atoms=atoms)
\ No newline at end of file
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index be30cbdb..c6224752 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -166,7 +166,7 @@ def __call__(
                     self.nstep / (time() - tstart),
                 )
                 log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
-
+                
         return torch.cat(pos).requires_grad_()
 
     def configure_move(self, move: Dict):
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 3d430710..6bdc80b1 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -6,6 +6,7 @@
 import numpy as np
 
 from ... import log
+from ...utils.constants import BOHR2ANGS
 from .calculator_base import CalculatorBase
 
 try:
@@ -85,12 +86,13 @@ def init_plams(self):
         """Init PLAMS."""
         plams.init()
         plams.config.log.stdout = -1
+        plams.config.log.file = -1
         plams.config.erase_workdir = True
 
     def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
-        bohr2angs = 0.529177 # the coordinate are always in bohr
+        bohr2angs = BOHR2ANGS # the coordinate are always in bohr
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(bohr2angs * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index f3b51900..2f5842e8 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -7,6 +7,7 @@
 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:
@@ -235,7 +236,7 @@ def _get_atomic_properties(self, atoms):
 
             conv2bohr = 1
             if self.unit == "angs":
-                conv2bohr = 1.8897259886
+                conv2bohr = ANGS2BOHR
             self.atom_coords.append([x * conv2bohr, y * conv2bohr, z * conv2bohr])
 
             self.atomic_number.append(element(atom_data[0]).atomic_number)
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index bc7b33b0..290ac73b 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -171,7 +171,7 @@ def geo_opt(  # pylint: disable=too-many-arguments
         geo_lr=1e-2,
         batchsize=None,
         nepoch_wf_init=100,
-        nepoch_wf_update=50,
+        nepoch_wf_update=10,
         hdf5_group="geo_opt",
         chkpt_every=None,
         tqdm=False,
@@ -217,7 +217,7 @@ def geo_opt(  # pylint: disable=too-many-arguments
             # 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.evaluate_gradient = self.evaluate_grad_auto # evaluate_grad_manual not valid for forces
             self.run_epochs(1)
             xyz.append(self.wf.geometry(None))
 
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

From 4b2a9ad938a56922a9f9af1f95860131f479f4a1 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 14 Feb 2025 19:24:29 +0100
Subject: [PATCH 222/286] fix other bug

---
 docs/example/ase/H2.xyz    |   4 ++--
 docs/example/ase/final.xyz |   6 +++---
 docs/example/ase/h2.py     |   4 ++--
 docs/example/ase/traj.xyz  | Bin 2850 -> 646 bytes
 qmctorch/ase/ase.py        |  11 +++++------
 5 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
index f6a613bb..bbc6f259 100644
--- a/docs/example/ase/H2.xyz
+++ b/docs/example/ase/H2.xyz
@@ -1,4 +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
+H        0.00025322       0.00003503      -0.35076029
+H       -0.00004153       0.00013435       0.35092507
diff --git a/docs/example/ase/final.xyz b/docs/example/ase/final.xyz
index af045fb9..0058387d 100644
--- a/docs/example/ase/final.xyz
+++ b/docs/example/ase/final.xyz
@@ -1,4 +1,4 @@
 2
-Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1601088283229546 pbc="F F F"
-H       -0.00030645       0.00039310      -0.36055667      -0.00204301       0.00262068      -0.07037781
-H       -0.00113510      -0.00025389       0.35945925      -0.00756733      -0.00169257       0.06306168
+Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1593882640770514 pbc="F F F"
+H       -0.00008958      -0.00000280      -0.36005114      -0.00059719      -0.00001867      -0.06700762
+H       -0.00753126       0.00175124       0.34909346      -0.05020839       0.01167497      -0.00604360
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 7bb2723f..fcffd600 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -27,9 +27,9 @@
 
 # sampler options
 h2.calc.sampler_options.nwalkers = 100
-h2.calc.sampler_options.nstep  = 5000
+h2.calc.sampler_options.nstep  = 500
 h2.calc.sampler_options.step_size = 0.5
-h2.calc.sampler_options.ntherm = 4000
+h2.calc.sampler_options.ntherm = 400
 h2.calc.sampler_options.ndecor = 10
 
 # solver options
diff --git a/docs/example/ase/traj.xyz b/docs/example/ase/traj.xyz
index c2c43df80fd49ad0f274cc52a29b2f0679e6d72d..aee09606d7a6274f22188f53aef42f21e6a683b2 100644
GIT binary patch
delta 96
zcmZ1^*2X$Pfs2s=0t^@?YWe9G{0%y${BEW_Lw<#_{^lI}ivNcVSC(zw&ropRDTt|X
yKSRRhwLhA>?X$KfoM~LQedF>ujQpksX6A+_My3{qhQ?-QMw9=t>rHN8VgmqAts=kx

literal 2850
zcmdN@$WK!U&B=8PcGV3jO3X@4F3B&dR8U}MfB-fq{R1kn0?KDZqoG_ll?Dda_QM6B
z45+yMgJY{UHSS5+pR%OQ{A+ot{eRAH$K6>r?Qi&-l>X*l-F}9}o8GDKj^2NYIkMus
z$_D#uPz$S-%2JDpGxPJ5tP~7&6qFK+Q{xdLO2&Fd#(D-yK#7#p;^d;tf)a?*YNe9O
zf>fX$rF@`JZe~>?SOTaH%1<o<NxFFkxq>w3CRW53m!uXH0|gC${LH+P)S|M)9FV28
zKz>0|GLRXamY7qVs-u8R#R6sXN^_Hdj?@DxsaDEMNh~T#tOO~KHUh~4%`!6qT4HJz
z3pOghI1}U+Y|3>Mj6pima`F=)dd!W$dXiIfKu(E{HqZmQ4n_c#5)uHJmYkTAT$+;z
zjAp0<6LY}<Q<w{i`s56d{|gd}fTBP@g94yhDJL;0H3!7ZE6vFPIXX2jwJ06rCtX85
zLo)+I0}Bfy3u7ZAOH&gwkb{Bdq!Q&JLnDLO+S*!WWji+|CGDKA`&2)=R$Z?8ZMUy3
z+v#25wf!EIM{Y-66W;GJv1WVe{*U_<r}C%mF1SW=`r&}5p8`?>+|0ycn1#5RB{1F9
z*241f3noa$T)_&V71$y43=Rk_zy+a4N&F$OZp+L_1wn!RcS^R*mYXADpTEBJ*WZq7
z``>I`cCziD?*2D7ttK1H=h{E*Q(|grE9vQ%i@fw}Xly#{iVPD2Xqll51dwo7fQGw@
zeZ`NKzNxEW;cg2Jcd7ly>S9w;me4QU&5edz!C`1_4lX%Bp{}fa_WG(<rpLARZ{L=!
zb416`{$}LNe_L)|+dpgi)}RlkJ@(Jq8m$_vueN`qB~$W_vvdo0BSQm|VOC%p8G^Df
zsE!1ITZ#+?8KNfpg(fX@QafyEKl$<|uNdL$`?nZ!*nOE1wBO_eOHAEjgZ<&k0f~u>
e*GaA?$t-7#Oe}zz64bgFHcb;FQ&1MJtpxyx@Gt2A

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index c724c9e2..6f92ffeb 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -412,10 +412,10 @@ def calculate(self, atoms=None, properties=['energy'], system_changes=None):
         # compute
         for p in properties:
             if p == 'forces':
-                self._calculate_forces(atoms=atoms)
+                return self._calculate_forces(atoms=atoms)
 
             elif p == 'energy':
-                self._calculate_energy(atoms=atoms)
+                return self._calculate_energy(atoms=atoms)
 
     def _calculate_energy(self, atoms=None):
         # check if reset is necessary 
@@ -441,8 +441,6 @@ def _calculate_energy(self, atoms=None):
         energy of the system. The result is stored in the calculator's results dictionary and
         returned.
         """
-        self.reset_solver(atoms=atoms)
-
         # optimize the wave function
         if self.solver_options.niter > 0:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
@@ -477,8 +475,6 @@ def _calculate_forces(self, atoms=None):
         The forces are computed by optimizing the wave function using the atomic positions as variational parameters.
         """
 
-        self.reset_solver(atoms=atoms)
-
         # optimize the wave function
         if self.solver_options.niter > 0:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
@@ -529,6 +525,8 @@ def get_forces(self, atoms=None):
         forces : array
             The total forces on the atoms.
         """
+        
+        self.reset_solver(atoms=atoms)
         if self.check_forces():
             return self.results['forces']
         else:
@@ -548,6 +546,7 @@ def get_total_energy(self, atoms=None):
         energy : float
             The total energy of the system.
         """
+        self.reset_solver(atoms=atoms)
         if 'energy' in self.results:
             return self.results['energy']
         else:

From 4fffb3abb2db3238ca603a800a2418c0b8ff08ca Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 17 Feb 2025 11:17:57 +0100
Subject: [PATCH 223/286] ase optimizer with torch

---
 docs/example/ase/H2.xyz                 |   4 +-
 docs/example/ase/final.xyz              |   6 +-
 docs/example/ase/h2.py                  |  11 +-
 docs/example/ase/traj.xyz               | Bin 646 -> 1824 bytes
 qmctorch/ase/optimizer/__init__.py      |   1 +
 qmctorch/ase/optimizer/torch_optim.py   | 150 ++++++++++++++++++++++++
 qmctorch/scf/calculator/adf.py          |   9 +-
 qmctorch/solver/solver.py               |  34 ++++--
 qmctorch/wavefunction/slater_jastrow.py |  11 ++
 9 files changed, 204 insertions(+), 22 deletions(-)
 create mode 100644 qmctorch/ase/optimizer/__init__.py
 create mode 100644 qmctorch/ase/optimizer/torch_optim.py

diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
index bbc6f259..f6a613bb 100644
--- a/docs/example/ase/H2.xyz
+++ b/docs/example/ase/H2.xyz
@@ -1,4 +1,4 @@
 2
 Properties=species:S:1:pos:R:3 pbc="F F F"
-H        0.00025322       0.00003503      -0.35076029
-H       -0.00004153       0.00013435       0.35092507
+H        0.00000000       0.00000000      -0.35000000
+H        0.00000000       0.00000000       0.35000000
diff --git a/docs/example/ase/final.xyz b/docs/example/ase/final.xyz
index 0058387d..94a274c6 100644
--- a/docs/example/ase/final.xyz
+++ b/docs/example/ase/final.xyz
@@ -1,4 +1,4 @@
 2
-Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1593882640770514 pbc="F F F"
-H       -0.00008958      -0.00000280      -0.36005114      -0.00059719      -0.00001867      -0.06700762
-H       -0.00753126       0.00175124       0.34909346      -0.05020839       0.01167497      -0.00604360
+Properties=species:S:1:pos:R:3 pbc="F F F"
+H       -0.00205573      -0.00021647      -0.66313765
+H        0.00047325       0.00062716       0.66299238
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index fcffd600..90c7ef6f 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,4 +1,5 @@
 from qmctorch.ase import QMCTorch     
+from qmctorch.ase.optimizer import TorchOptimizer
 from ase import Atoms 
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
@@ -45,12 +46,10 @@
 
 # Optimize the wave function
 h2.calc.set_solver()
-h2.get_total_energy()
 
-# change the number of steps
-h2.calc.solver_options.niter = 5
-
-# use FIRE for the optimization
-dyn = FIRE(h2, trajectory='traj.xyz')
+# use torch optim for the optimization
+dyn = TorchOptimizer(h2, trajectory='traj.xyz', 
+                     nepoch_wf_init=10, nepoch_wf_update=5, 
+                     tqdm=True)
 dyn.run(fmax=0.005, steps=5)
 write('final.xyz',h2)
diff --git a/docs/example/ase/traj.xyz b/docs/example/ase/traj.xyz
index aee09606d7a6274f22188f53aef42f21e6a683b2..d0d86a453259f9020ef0ed76486912cd19e0eb02 100644
GIT binary patch
delta 539
zcmZo;UBEX%L6DUJ3YZ~u#Y97K!-rm`%?Vx>`zII~@u$e^?Qd7ExXPmUbpP4;Z}uPG
zreS}FtL4-AjY{@!R>g}H>OHmZpSUuWFC@PxIm5r8Br`X&Dz#{{5ThcaO>M1m^%G&%
ztWAOY`|sseE??<l-;nwC$qUn``x^@Ob92r!vY%y8+xlXTroGOb6V38QPwlru-BUfe
zfl-gy)W~A;2F7Mppg|Q-2?r(!qk#oN7eKv`z&6oQd}06xT@btFzVpl#Q;MVZJ6w8X
z@h?Dc|91TVClTYP`+eG4Jg3NO+b5lx8(n|a-rksPZ?X)~UptWf#bRh^U;^@(b#1Lw
z*V-AJsd4)`PQ6|GT2Fibx>F19RhvBBztGNp`2iafdj=sN!Nf>cd)?L9x71BB3^F!>
z8Ps!O@jJci3Hy)6+Ojmq>+C;$(4a8K;_3dQ>n?pi#%ynYbnQ$x_FflzzQpgRtj#eD
MGPM93#8g`g08N0q8UO$Q

delta 177
zcmZ3$*Ty<QL6DIF0t}$^iiw8elP#D90@J|Y+J2}woPvtm7yJ!6ru=TEJwtwlvi{~A
z`-=aE4Of<J-p^2Q-zkWxa6d!B<+VSWyX~{KCY)(px845Q#L83_H_sr~jc*hg)pZn<
zQu9)a(kqp$6m$*s3{4Hp%neP9Of3uzjm^xAfYNFCMaij?lNnXn4UG(9Yinx(mku_M

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..e8d48f09
--- /dev/null
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -0,0 +1,150 @@
+from typing import IO, Any, Callable, Dict, List, Optional, Union
+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
+
+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,
+                 force_consistent=Optimizer._deprecated):
+        
+
+        Optimizer.__init__(self, atoms, restart, logfile, trajectory,
+                           master, force_consistent=force_consistent)
+        
+        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, forces):
+        """
+        Write to the log file.
+
+        Parameters
+        ----------
+        e : float
+            Energy of the system.
+        forces : array
+            Forces on the atoms.
+
+        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()
+
+    
+    def run(self, fmax, steps=10, hdf5_group="geo_opt"):
+        """
+        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
+            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)
+            forces = solver.wf.forces()
+            self.xyz_trajectory.append(solver.wf.geometry(None))
+
+            # 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))
+            self.log(cumulative_loss, forces)
+            self.call_observers()
+
+        # 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
\ No newline at end of file
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 6bdc80b1..22006a91 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -78,7 +78,10 @@ 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
 
@@ -89,6 +92,10 @@ def init_plams(self):
         plams.config.log.file = -1
         plams.config.erase_workdir = True
 
+    def finish_plams(self):
+        """Finish PLAMS."""
+        plams.finish()
+
     def get_plams_molecule(self):
         """Returns a plams molecule object."""
         mol = plams.Molecule()
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 290ac73b..e9bafb2f 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -1,6 +1,6 @@
 from copy import deepcopy
 from time import time
-
+from tqdm import tqdm
 import torch
 from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 
@@ -316,24 +316,36 @@ def save_data(self, hdf5_group):
 
         add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
-    def run_epochs(self, nepoch):
+    def run_epochs(self, nepoch, with_tqdm=False, verbose=True):
         """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):
-            tstart = time()
-            log.info("")
-            log.info(
-                "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
-            )
+        for n in rng:
+
+            if verbose:
+                tstart = time()
+                log.info("")
+                log.info(
+                    "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
+                )
 
             cumulative_loss = 0
 
@@ -369,7 +381,8 @@ def run_epochs(self, nepoch):
                 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.dataloader.dataset = self.resample(n, self.dataloader.dataset)
@@ -378,7 +391,8 @@ def run_epochs(self, nepoch):
             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
 
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 44b77845..99b26313 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -644,6 +644,17 @@ def geometry(self, pos):
             xyz = self.ao.atom_coords[iat, :].cpu().detach().numpy().tolist()
             d.append(xyz)
         return d
+    
+    def forces(self):
+        """
+        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=False):
         """Fits the AO GTO to AO STO.

From c7fe5fc2e8d7b5ca301b243de857b38b82c2ffb0 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 17 Feb 2025 11:26:37 +0100
Subject: [PATCH 224/286] ase optimizer with torch

---
 docs/example/ase/h2.py                | 6 ++++--
 qmctorch/ase/optimizer/torch_optim.py | 7 +++++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 90c7ef6f..48599bdc 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -48,8 +48,10 @@
 h2.calc.set_solver()
 
 # use torch optim for the optimization
-dyn = TorchOptimizer(h2, trajectory='traj.xyz', 
-                     nepoch_wf_init=10, nepoch_wf_update=5, 
+dyn = TorchOptimizer(h2, 
+                     trajectory='traj.xyz', 
+                     nepoch_wf_init=10, 
+                     nepoch_wf_update=5, 
                      tqdm=True)
 dyn.run(fmax=0.005, steps=5)
 write('final.xyz',h2)
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index e8d48f09..e62c08fb 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -64,7 +64,7 @@ def log(self, e, forces):
             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, steps=10, hdf5_group="geo_opt"):
         """
@@ -137,9 +137,12 @@ def run(self, fmax, steps=10, hdf5_group="geo_opt"):
 
             # update the geometry
             self.optimizable.set_positions(solver.wf.geometry(None))
-            self.log(cumulative_loss, forces)
+            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()
 

From d9f125d7176e580b207149f9e752ec62f9ee7666 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 18 Feb 2025 13:31:45 +0100
Subject: [PATCH 225/286] removed internal geo opt

---
 docs/example/ase/final.xyz              |   4 --
 docs/example/ase/h2.py                  |  10 +--
 docs/example/ase/traj.xyz               | Bin 1824 -> 0 bytes
 qmctorch/ase/ase.py                     |   2 +-
 qmctorch/ase/optimizer/torch_optim.py   |   9 +--
 qmctorch/solver/solver.py               |  80 +-----------------------
 qmctorch/wavefunction/slater_jastrow.py |  10 ++-
 7 files changed, 20 insertions(+), 95 deletions(-)
 delete mode 100644 docs/example/ase/final.xyz
 delete mode 100644 docs/example/ase/traj.xyz

diff --git a/docs/example/ase/final.xyz b/docs/example/ase/final.xyz
deleted file mode 100644
index 94a274c6..00000000
--- a/docs/example/ase/final.xyz
+++ /dev/null
@@ -1,4 +0,0 @@
-2
-Properties=species:S:1:pos:R:3 pbc="F F F"
-H       -0.00205573      -0.00021647      -0.66313765
-H        0.00047325       0.00062716       0.66299238
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 48599bdc..a06128df 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -28,9 +28,9 @@
 
 # sampler options
 h2.calc.sampler_options.nwalkers = 100
-h2.calc.sampler_options.nstep  = 500
+h2.calc.sampler_options.nstep  = 5000
 h2.calc.sampler_options.step_size = 0.5
-h2.calc.sampler_options.ntherm = 400
+h2.calc.sampler_options.ntherm = 4000
 h2.calc.sampler_options.ndecor = 10
 
 # solver options
@@ -45,13 +45,13 @@
 h2.calc.solver_options.resampling.ntherm_update = 100
 
 # Optimize the wave function
-h2.calc.set_solver()
+h2.calc.initialize()
 
 # use torch optim for the optimization
 dyn = TorchOptimizer(h2, 
                      trajectory='traj.xyz', 
-                     nepoch_wf_init=10, 
-                     nepoch_wf_update=5, 
+                     nepoch_wf_init=50, 
+                     nepoch_wf_update=15, 
                      tqdm=True)
 dyn.run(fmax=0.005, steps=5)
 write('final.xyz',h2)
diff --git a/docs/example/ase/traj.xyz b/docs/example/ase/traj.xyz
deleted file mode 100644
index d0d86a453259f9020ef0ed76486912cd19e0eb02..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1824
zcmdN@$WK!U&B=8PcGV3jO3X@4F3B&dR8U}MfB;q~%>Wgsfbtp9=!agW%?Vx>`zII~
z@u$e^?Qd7ExXPmUbpP4;Z}uPGreS}FtL4-AjY{@!R>g}H>OHmZhZ<0=RF+y)oSC1e
zWTjxJqo9;noEnc1Q8LyuGS)Lt0!pN$7AF^F7L-7gRx6cM7Ni38DCGl%ax<$E!4g1q
zP=0C=NHQe9C^^F)q5>!al+I18h%YWlEhq*`8vyy4c_pbuWr;Z;>uZ7hf}~_1Gde9X
zr#Mwd0hx*g%I1~kCIOwR2UJq6l$VlNRFqf=QXXvtk_DP&W&*Ut)GQWkRDN+L$W_>s
z>nIq5bfo3vCqnd?8-evCr{;j15*=-z2Xq~b04gOU05UB(F(<h+ClMHdPzNUFf`h0q
z7Zj<<86f``Bo+Zhfqn)BK($g%Vp3`jh?!TKlT%w;t6cp=m^Eut;Qs!5xs}UTy4W{l
zzJ2n-^y&VFg8kf_^Nj3g8PvAEn4@X0Gv`FJywOwp?a*{ktyDmYcTJ5f28VxP>Dhq^
z;*kax2web8_z7%K4~|kqg}}b^%oS6LqxL&odSvl0KyUwc{QxHs<EQ(5+FCrP$ZOjt
zothh6f7agKm~C&e3^4udfSO8T`Y|*#Fc}mHNUCe?49?WJ{T!#>u6?biy?@=Qh4-pW
zp6*|0XTSV_jfp*jkdI(uq^rH|>g-$UrsVtA*ko|{x97s*cY4<o_8*P4WoeGr*?;<=
pL1B)?)BQ)+UHX2E+1~!>+L><by)O2AiQi9Io0IQfQ;WgjUjUo4$p`=d

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 6f92ffeb..3e687cf2 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -260,7 +260,7 @@ def set_resampling_options(self):
             if self.solver_options.resampling.ntherm_update != -1:
                 self.solver_options.resampling.ntherm_update = -1
 
-    def set_solver(self):
+    def initialize(self):
         """
         Set the default solver object for the QMCTorchCalculator.
 
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index e62c08fb..400cd46d 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -8,7 +8,7 @@
 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, 
@@ -123,9 +123,10 @@ def run(self, fmax, steps=10, hdf5_group="geo_opt"):
             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)
+            solver.run_epochs(1, verbose=False)
             forces = solver.wf.forces()
-            self.xyz_trajectory.append(solver.wf.geometry(None))
+            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)
@@ -136,7 +137,7 @@ def run(self, fmax, steps=10, hdf5_group="geo_opt"):
                                                 with_tqdm=self.tqdm, verbose=False)
 
             # update the geometry
-            self.optimizable.set_positions(solver.wf.geometry(None))
+            self.optimizable.set_positions(solver.wf.geometry(None,convert_to_angs=True))
             current_fmax = self.log(cumulative_loss, forces)
             self.call_observers()
 
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index e9bafb2f..be7f7bc4 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -165,83 +165,6 @@ def restore_sampling_parameters(self):
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
-    def geo_opt(  # pylint: disable=too-many-arguments
-        self,
-        nepoch,
-        geo_lr=1e-2,
-        batchsize=None,
-        nepoch_wf_init=100,
-        nepoch_wf_update=10,
-        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 # evaluate_grad_manual not valid for forces
-            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()
-
-        # 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
@@ -347,9 +270,10 @@ def run_epochs(self, nepoch, with_tqdm=False, verbose=True):
                     "  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):
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 99b26313..7d925597 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -20,6 +20,7 @@
 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):
@@ -630,7 +631,7 @@ 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):
+    def geometry(self, pos, convert_to_angs=False):
         """Returns the gemoetry of the system in xyz format
 
         Args:
@@ -640,9 +641,12 @@ def geometry(self, pos):
             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().tolist()
-            d.append(xyz)
+            xyz = self.ao.atom_coords[iat, :].cpu().detach().numpy() * convert
+            d.append(xyz.tolist())
         return d
     
     def forces(self):

From c5fb94bd4d7b7a9f7988d69022cb3fbc110c3aa5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 19 Feb 2025 13:08:34 +0100
Subject: [PATCH 226/286] optimizer

---
 docs/example/ase/H2.xyz        |   4 ++--
 docs/example/ase/final.xyz     |   4 ++++
 docs/example/ase/h2.py         |  11 ++++++-----
 docs/example/ase/h2_cc.py      |  16 ++++++++++++++++
 docs/example/ase/traj.xyz      | Bin 0 -> 2850 bytes
 qmctorch/ase/ase.py            |   4 ++--
 qmctorch/solver/solver_base.py |   3 +++
 7 files changed, 33 insertions(+), 9 deletions(-)
 create mode 100644 docs/example/ase/final.xyz
 create mode 100644 docs/example/ase/h2_cc.py
 create mode 100644 docs/example/ase/traj.xyz

diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
index f6a613bb..df13d6b0 100644
--- a/docs/example/ase/H2.xyz
+++ b/docs/example/ase/H2.xyz
@@ -1,4 +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
+H       -0.00006220       0.00016371      -0.36154484
+H       -0.00038780      -0.00007285       0.36119408
diff --git a/docs/example/ase/final.xyz b/docs/example/ase/final.xyz
new file mode 100644
index 00000000..ef4a9e6a
--- /dev/null
+++ b/docs/example/ase/final.xyz
@@ -0,0 +1,4 @@
+2
+Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1549469664851448 pbc="F F F"
+H       -0.00006220       0.00016371      -0.36154484      -0.00228690       0.00002327      -0.06469450
+H       -0.00038780      -0.00007285       0.36119408      -0.00198507      -0.00181126       0.06786540
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index a06128df..b367b48c 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -48,10 +48,11 @@
 h2.calc.initialize()
 
 # use torch optim for the optimization
-dyn = TorchOptimizer(h2, 
-                     trajectory='traj.xyz', 
-                     nepoch_wf_init=50, 
-                     nepoch_wf_update=15, 
-                     tqdm=True)
+# dyn = TorchOptimizer(h2, 
+#                      trajectory='traj.xyz', 
+#                      nepoch_wf_init=50, 
+#                      nepoch_wf_update=15, 
+#                      tqdm=True)
+dyn = FIRE(h2, trajectory='traj.xyz')
 dyn.run(fmax=0.005, steps=5)
 write('final.xyz',h2)
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/traj.xyz b/docs/example/ase/traj.xyz
new file mode 100644
index 0000000000000000000000000000000000000000..e0d228c307881f9364d462cf377a4274a921f896
GIT binary patch
literal 2850
zcmeHJeN0<b6t98<SzHiAhGY8jI*@F%d*6MJKYCekpJds>My4RbYk922*AHIXDb$jx
zBS@TVEK7zsH<&~Vo5+G=jxD<k#TmmIjIm^zI3iP-iw2$Bx|l8A*A_I!sO2yI@cr@5
zJzw{p^Lyu<`*fJ21}l|qYqqV`ZCAuv$?SG0^%$0*i9U;BG#nEIV*EXSp)q!j)I^>T
zoD;+rF*(r8tX`M=$Wt)6rA4{5sSy+u1(#g!J_h#<{u0c2wHX!$Ix`<C+y<^(J6mC{
z>H%NG4)o%?B*kTQ*zp34%*SxiB~|_*!D&53>j@kwswJ0Mu{zyRQ!nnWcS^_ycOa3?
z+8{<0$S%f9imF_<v1G04Y!jcabh#y`3keCtTkUR1*(J*Ap+3YrO=h$#uMuUJl#l(H
zR3NS0V>6*3^~l7F+p9%I5$jd+a!S>ry*LIP!g3XntsE|^8q43A=VP?$Q6oFVsE>h)
z_?RVG4W+!C(4**PU&!>|1nO>PQ8s&I5q;)ZfTAq|Or1^r^k$2izf)9@6y>Y};KgOp
zB+2U1?vZ6RXvr=qJJp<Yq@H92k|JoHCIm)ccr{+Mjr5=LL5>wZpHHjR8dLi4p46Fh
zrXxR})|u16hlZ?0z!8GrICmc6k3wTf#>mWD)5cn9x3S3{0{#JK!;5+uR(Y?K6@F6*
zmL1S$cU}4b`p0sDZ`ZAdnqgzmesd*wc=eCe_ZLrrq`CTW#sfIV@Cy-f!a$J>!y9OZ
z<+->J=LA%C2=UoIp1wEQn1TDE6ibTI_T(r{O^MR~-~Wt2>(FC%BKJYaG>$fN**T!&
znL7Dya|q(Cle+4|I=FbLru*slZX3fxrR~#AA&|GSc0%*G1q@IB)Y<{7;fhmh#&WNo
zgxHPCJ71T#1I?bpl}*>vKy&+0lH<(#AZ32_OVaFu92p$RZ~}!&nB@%u9ajaD3^6-2
z(A@C1mu?xooDOTm?yI{SR)K`XjDsKbh2XD)5A;1LF>uL|kmrTX3BdA1!>0YcXl|VU
zG;gM*1QhO=`n>pBHN?|`BxyPc3%%bhKDNFL<b64|<G{-<I9ay$PRWJAdE;)N7UbZd
zXqM&$hUNqVMN#qLZZJeg2SQz|wcN;Be!49UezNrqryR})Cw?OmG*cnyzgf`Mk;%jU
z-h*8mGJiOiWz8N>{yGFSM>F2^QZyJZC<@447aaR|H1R_50GvE~dsXXE5n$oe(RW))
zV7b3)*#I>F?w?=1QzXGG$broY951k}LEs1`F4!qj?cm5Asp4MH+1+z#b1Iy2T3%V<
z$pOWaZMXJlC*VtWjs1MB01s{G`u4S@>F_JZvm+OmPXPa&DPQ=E32Hh=-pQ51#>DK6
zy`SyvhyKRl8BI|Y<j3~~!pAG1W$@5*os}o%TkjOZqozcOEwEn`^hbhjJamh*>U|j>
K@T}UxKHu*_92Q&v

literal 0
HcmV?d00001

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 3e687cf2..17d3b984 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -368,10 +368,10 @@ def reset_solver(self, atoms=None, force=True):
             if not np.allclose(self.atoms.get_positions()*ANGS2BOHR, np.array(self.molecule.atom_coords)):
                 self.reset()
                 self.set_atoms(atoms)
-                self.set_solver()
+                self.initialize()
         else:
             if self.solver is None:
-                self.set_solver()
+                self.initialize()
 
     def calculate(self, atoms=None, properties=['energy'], system_changes=None):
         """
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index d829409d..e9123408 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -56,7 +56,10 @@ def __init__(  # pylint: disable=too-many-arguments
             basename = 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()

From 055deca8da427f691f5ce201de768faf4b4888f8 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 21 Feb 2025 18:22:12 +0100
Subject: [PATCH 227/286] typhints

---
 qmctorch/ase/ase.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 17d3b984..4dd9a0b6 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -102,7 +102,7 @@ def __init__(self,
         self.recognized_resampling_options = list(self.solver_options.resampling.__dict__.keys())
         
     @staticmethod
-    def validate_options(options, recognized_options, name=""):
+    def validate_options(options: SimpleNamespace, recognized_options: list, name: str = "") -> None:
         """
         Validate that the options provided are valid.
 
@@ -119,10 +119,16 @@ def validate_options(options, recognized_options, name=""):
         ------
         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))
+                raise ValueError(
+                    "Invalid %s options: %s. Recognized options are %s" % (name, opt, recognized_options)
+                )
 
     def run_scf(self):
         """

From 8716ebd937018aab9b4ec699123dedc818997a65 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 10:10:28 +0100
Subject: [PATCH 228/286] upgrde python for test

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 66845c08..6c879b1a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['3.8']
+        version: ['3.9']
 
     steps:
     - name: Cancel Previous Runs

From a9e4d1d430dbb68eb1dcf6bf017fe599812353ec Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 10:20:35 +0100
Subject: [PATCH 229/286] switched to miniconda

---
 .github/workflows/build.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6c879b1a..998959d7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -27,11 +27,11 @@ jobs:
           access_token: ${{ github.token }}
     - uses: actions/checkout@v4
     - name: Setup conda
-      uses: s-weigand/setup-conda@v1
+      uses: conda-incubator/setup-miniconda@v3
       with:
-        update-conda: true
+        auto-update-conda: true
         python-version: ${{ matrix.version }}
-        conda-channels: anaconda
+        channels: anaconda
     - name: Install essential
       run: |
         sudo apt update

From 7e70c512abdeaa3e39848c5a20ead4384e580d02 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 10:49:36 +0100
Subject: [PATCH 230/286] pip install torch as conda not supported anymore

---
 .github/workflows/build.yml | 24 ++++++++++++------------
 setup.py                    |  4 ++--
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 998959d7..8899c505 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -26,22 +26,22 @@ jobs:
       with:
           access_token: ${{ github.token }}
     - uses: actions/checkout@v4
-    - name: Setup conda
-      uses: conda-incubator/setup-miniconda@v3
-      with:
-        auto-update-conda: true
-        python-version: ${{ matrix.version }}
-        channels: anaconda
+    # - name: Setup conda
+    #   uses: conda-incubator/setup-miniconda@v3
+    #   with:
+    #     auto-update-conda: true
+    #     python-version: ${{ matrix.version }}
+    #     channels: anaconda
     - name: Install essential
       run: |
         sudo apt update
         sudo apt install build-essential pandoc
-    - name: Install conda packages
-      run: |
-        conda install -c anaconda cmake
-        conda install rdkit mpi4py h5py pytorch==2.1.1 cpuonly -c pytorch -c conda-forge
-        conda install -c conda-forge libstdcxx-ng
-        conda install -c anaconda gxx_linux-64
+    # - name: Install conda packages
+    #   run: |
+    #     conda install -c anaconda cmake
+    #     conda install rdkit mpi4py h5py pytorch==2.1.1 cpuonly -c pytorch -c conda-forge
+    #     conda install -c conda-forge libstdcxx-ng
+    #     conda install -c anaconda gxx_linux-64
 
     - name: Install the package
       run: python -m pip install .[test,doc]
diff --git a/setup.py b/setup.py
index 35dc95b4..7dfb002c 100644
--- a/setup.py
+++ b/setup.py
@@ -41,10 +41,10 @@
     ],
     test_suite='tests',
     install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch',
+                      'scipy', 'tqdm', 'torch', 'h5py',
                       'plams', 'pints', 'linetimer',
                       'pyscf', 'mendeleev', 'twiggy',
-                      'plams', 'mpi4py', 'ase'],
+                      'plams', 'ase'],
 
     extras_require={
         'hpc': ['horovod'],

From aa7fb763e8c5c5072091d980e97ee8f634b2963d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 11:12:45 +0100
Subject: [PATCH 231/286] swtch from np.math to math cause of python 3.9

---
 .github/workflows/build.yml                   |  2 +-
 .../wavefunction/orbitals/norm_orbital.py     |  5 +--
 tests/solver/test_h2_pyscf_geo_opt.py         | 34 +++++++++----------
 tests/solver/test_h2_pyscf_metropolis.py      | 34 +++++++++----------
 4 files changed, 38 insertions(+), 37 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 8899c505..523ad03d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
 
     strategy:
-      fail-fast: false
+      fail-fast: true
       matrix:
         version: ['3.9']
 
diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 72886b32..b272488c 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -1,5 +1,6 @@
 import torch
 import numpy as np
+import math
 from ...utils.algebra_utils import double_factorial
 
 def atomic_orbital_norm(basis):
@@ -57,7 +58,7 @@ def norm_slater_spherical(bas_n, bas_exp):
         torch.tensor: normalization factor
     """
     nfact = torch.as_tensor(
-        [np.math.factorial(2 * n) for n in bas_n], dtype=torch.get_default_dtype()
+        [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)
 
@@ -102,7 +103,7 @@ 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(
+    lfact = torch.as_tensor([math.factorial(int(2 * i)) for i in lvals]).type(
         torch.get_default_dtype()
     )
 
diff --git a/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
index 8b165e17..d299ab5d 100644
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ b/tests/solver/test_h2_pyscf_geo_opt.py
@@ -56,28 +56,28 @@ def setUp(self):
         # solver
         self.solver = Solver(wf=self.wf, sampler=self.sampler, optimizer=self.opt)
 
-    def test_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)
+    # def test_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)
+    #     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()
+    #     # 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
+    #     # sample and compute variables
+    #     obs = self.solver.single_point()
+    #     e, v = obs.energy, obs.variance
 
-        e = e.data.numpy()
-        v = v.data.numpy()
+    #     e = e.data.numpy()
+    #     v = v.data.numpy()
 
-        # it might be too much to assert with the ground state energy
-        gse = -1.16
-        assert e > 2 * gse and e < 0.0
-        assert v > 0 and v < 2.0
+    #     # it might be too much to assert with the ground state energy
+    #     gse = -1.16
+    #     assert e > 2 * gse and e < 0.0
+    #     assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":
diff --git a/tests/solver/test_h2_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 49d2f174..2fb926fd 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -64,28 +64,28 @@ def setUp(self):
         # values on different arch
         self.expected_variance = [0.9279592633247375, 0.7445300449383236]
 
-    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)
+    # 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)
+    #     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()
+    #     # 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
+    #     # sample and compute variables
+    #     obs = self.solver.single_point()
+    #     e, v = obs.energy, obs.variance
 
-        e = e.data.numpy()
-        v = v.data.numpy()
+    #     e = e.data.numpy()
+    #     v = v.data.numpy()
 
-        # it might be too much to assert with the ground state energy
-        gse = -1.16
-        assert e > 2 * gse and e < 0.0
-        assert v > 0 and v < 2.0
+    #     # it might be too much to assert with the ground state energy
+    #     gse = -1.16
+    #     assert e > 2 * gse and e < 0.0
+    #     assert v > 0 and v < 2.0
 
 
 if __name__ == "__main__":

From 07fa63467cc493d0d82f159260f83a72dd88355f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 11:49:48 +0100
Subject: [PATCH 232/286] added ase test

---
 .github/workflows/build.yml | 13 -------
 tests/ase/test_ase_calc.py  | 68 +++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 13 deletions(-)
 create mode 100644 tests/ase/test_ase_calc.py

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 523ad03d..9eacd168 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -26,23 +26,10 @@ jobs:
       with:
           access_token: ${{ github.token }}
     - uses: actions/checkout@v4
-    # - name: Setup conda
-    #   uses: conda-incubator/setup-miniconda@v3
-    #   with:
-    #     auto-update-conda: true
-    #     python-version: ${{ matrix.version }}
-    #     channels: anaconda
     - name: Install essential
       run: |
         sudo apt update
         sudo apt install build-essential pandoc
-    # - name: Install conda packages
-    #   run: |
-    #     conda install -c anaconda cmake
-    #     conda install rdkit mpi4py h5py pytorch==2.1.1 cpuonly -c pytorch -c conda-forge
-    #     conda install -c conda-forge libstdcxx-ng
-    #     conda install -c anaconda gxx_linux-64
-
     - name: Install the package
       run: python -m pip install .[test,doc]
       env:
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)

From 836534588dfbb477132aae01a24688f0c250e9f7 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 13:08:23 +0100
Subject: [PATCH 233/286] remove force consistent from opt

---
 docs/example/ase/H2.xyz                       |   4 +--
 .../ase/plams_workdir/HH_dzp/HH_dzp.err       |   1 +
 .../ase/plams_workdir/HH_dzp/HH_dzp.in        |  25 ++++++++++++++++++
 .../ase/plams_workdir/HH_dzp/HH_dzp.out       |   0
 .../ase/plams_workdir/HH_dzp/HH_dzp.run       |   5 ++++
 docs/example/ase/plams_workdir/logfile        |   5 ++++
 qmctorch/ase/optimizer/torch_optim.py         |   5 ++--
 tests/H2.xyz                                  |   4 +++
 tests/traj.xyz                                | Bin 0 -> 1104 bytes
 9 files changed, 44 insertions(+), 5 deletions(-)
 create mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
 create mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
 create mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out
 create mode 100755 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
 create mode 100644 docs/example/ase/plams_workdir/logfile
 create mode 100644 tests/H2.xyz
 create mode 100644 tests/traj.xyz

diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
index df13d6b0..f6a613bb 100644
--- a/docs/example/ase/H2.xyz
+++ b/docs/example/ase/H2.xyz
@@ -1,4 +1,4 @@
 2
 Properties=species:S:1:pos:R:3 pbc="F F F"
-H       -0.00006220       0.00016371      -0.36154484
-H       -0.00038780      -0.00007285       0.36119408
+H        0.00000000       0.00000000      -0.35000000
+H        0.00000000       0.00000000       0.35000000
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
new file mode 100644
index 00000000..b0b5c678
--- /dev/null
+++ b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
@@ -0,0 +1 @@
+ERROR: AMSHOME environment variable is not set. Source the amsbashrc.sh file.
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
new file mode 100644
index 00000000..f3dd6d6f
--- /dev/null
+++ b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
@@ -0,0 +1,25 @@
+Task SinglePoint
+
+system
+  Atoms
+              H       0.0000000000       0.0000000000      -0.3499998353 
+              H       0.0000000000       0.0000000000       0.3499998353 
+  End
+End
+
+Engine adf
+  XC
+    HartreeFock
+  End
+  basis
+    core None
+    type DZP
+  End
+  relativity
+    level None
+  End
+  symmetry nosym
+  totalenergy
+EndEngine
+
+
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out
new file mode 100644
index 00000000..e69de29b
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
new file mode 100755
index 00000000..c313d993
--- /dev/null
+++ b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+unset AMS_SWITCH_LOGFILE_AND_STDOUT
+AMS_JOBNAME="HH_dzp" AMS_RESULTSDIR=. $AMSBIN/ams <"HH_dzp.in"
+
diff --git a/docs/example/ase/plams_workdir/logfile b/docs/example/ase/plams_workdir/logfile
new file mode 100644
index 00000000..4f408ce5
--- /dev/null
+++ b/docs/example/ase/plams_workdir/logfile
@@ -0,0 +1,5 @@
+[25.02|13:05:17] Running PLAMS located in /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams
+[25.02|13:05:17] Using Python 3.8.0 located in /home/nico/anaconda3/envs/qmctorch/bin/python
+[25.02|13:05:17] PLAMS defaults were loaded from /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams/plams_defaults
+[25.02|13:05:17] PLAMS environment initialized
+[25.02|13:05:17] PLAMS working folder: /home/nico/QMCTorch/docs/example/ase/plams_workdir
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index 400cd46d..fd719fe3 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -21,12 +21,11 @@ def __init__(self,
                  restart: Optional[str] = None,
                  logfile: Union[IO, str] = '-',
                  trajectory: Optional[str] = None,
-                 master: Optional[bool] = None,
-                 force_consistent=Optimizer._deprecated):
+                 master: Optional[bool] = None):
         
 
         Optimizer.__init__(self, atoms, restart, logfile, trajectory,
-                           master, force_consistent=force_consistent)
+                           master)
         
         self.opt_geo = optimizer
         self.batchsize = batchsize
diff --git a/tests/H2.xyz b/tests/H2.xyz
new file mode 100644
index 00000000..f6a613bb
--- /dev/null
+++ b/tests/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/tests/traj.xyz b/tests/traj.xyz
new file mode 100644
index 0000000000000000000000000000000000000000..1be286dd99b387c3cb3f3cc42edb3d6c0ef613ef
GIT binary patch
literal 1104
zcmdN@$WK!U&B=8PcGV3jO3X@4F3B&dR8U}MfB+^a%>Wgsfbtp9XrCaXuQLzn?JtX3
zaqrA33HuY94XUSCT-&eZXO~p0^?jf31&4&4vjy#E@CRlX7hSXOhZ<0=RF+y)oSC1e
zWTjxJqo9;noEnc1Q8LyuGS)Lt0!pN$7AF^F7L-7gRx6cM7Ni38DCGl%ax<$E!4g1q
zP=0C=NHQe9C^^F)q5>!al+I18h%YWlEhq*`8vyy4c_pbuWr;Z;>uZ7hf}~_1Gde9X
zr#Mwd0hx*g%I1~kCIOwR2UJq6l$VlNRFqf=QXXvtk_DP&W&*Ut)GQWkRDN+L$W_>s
z>nIq5bfo3vCqnd?8-evCr{;j15*=-z2Xq~b04gOU05UB(F(<h+ClMHdPzNUFf`h0q
z7Zj<<86f``Bo+Zhfqn)BK($g%Vp3`jh?!TKlT%w;tNiJ2VeZ`7I{Pct?Ht+_)$H@a
zgsaQjukD``y1#x_zW9D4;Z=TZYoFTH3mkCQZoX!}9hwfRl?q7luBnm5;P5XjJv+b?
MIxNAD(&U5y0HwC$<p2Nx

literal 0
HcmV?d00001


From 4864a4c69da60bf0d934122957689e00d86367ef Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 13:23:43 +0100
Subject: [PATCH 234/286] clean up

---
 docs/example/ase/H2.xyz                       |   4 -
 docs/example/ase/final.xyz                    |   4 -
 .../ase/plams_workdir/HH_dzp/HH_dzp.err       |   1 -
 .../ase/plams_workdir/HH_dzp/HH_dzp.in        |  25 -----
 .../ase/plams_workdir/HH_dzp/HH_dzp.out       |   0
 .../ase/plams_workdir/HH_dzp/HH_dzp.run       |   5 -
 docs/example/ase/plams_workdir/logfile        |   5 -
 docs/example/ase/traj.xyz                     | Bin 2850 -> 0 bytes
 qmctorch/sampler/metropolis.py                |   2 +-
 tests/H2.xyz                                  |   4 -
 tests/solver/test_h2_pyscf_geo_opt.py         |  90 ------------------
 tests/solver/test_h2_pyscf_metropolis.py      |  23 -----
 tests/traj.xyz                                | Bin 1104 -> 0 bytes
 13 files changed, 1 insertion(+), 162 deletions(-)
 delete mode 100644 docs/example/ase/H2.xyz
 delete mode 100644 docs/example/ase/final.xyz
 delete mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
 delete mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
 delete mode 100644 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out
 delete mode 100755 docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
 delete mode 100644 docs/example/ase/plams_workdir/logfile
 delete mode 100644 docs/example/ase/traj.xyz
 delete mode 100644 tests/H2.xyz
 delete mode 100644 tests/solver/test_h2_pyscf_geo_opt.py
 delete mode 100644 tests/traj.xyz

diff --git a/docs/example/ase/H2.xyz b/docs/example/ase/H2.xyz
deleted file mode 100644
index f6a613bb..00000000
--- a/docs/example/ase/H2.xyz
+++ /dev/null
@@ -1,4 +0,0 @@
-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/final.xyz b/docs/example/ase/final.xyz
deleted file mode 100644
index ef4a9e6a..00000000
--- a/docs/example/ase/final.xyz
+++ /dev/null
@@ -1,4 +0,0 @@
-2
-Properties=species:S:1:pos:R:3:forces:R:3 energy=-1.1549469664851448 pbc="F F F"
-H       -0.00006220       0.00016371      -0.36154484      -0.00228690       0.00002327      -0.06469450
-H       -0.00038780      -0.00007285       0.36119408      -0.00198507      -0.00181126       0.06786540
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
deleted file mode 100644
index b0b5c678..00000000
--- a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.err
+++ /dev/null
@@ -1 +0,0 @@
-ERROR: AMSHOME environment variable is not set. Source the amsbashrc.sh file.
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
deleted file mode 100644
index f3dd6d6f..00000000
--- a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.in
+++ /dev/null
@@ -1,25 +0,0 @@
-Task SinglePoint
-
-system
-  Atoms
-              H       0.0000000000       0.0000000000      -0.3499998353 
-              H       0.0000000000       0.0000000000       0.3499998353 
-  End
-End
-
-Engine adf
-  XC
-    HartreeFock
-  End
-  basis
-    core None
-    type DZP
-  End
-  relativity
-    level None
-  End
-  symmetry nosym
-  totalenergy
-EndEngine
-
-
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.out
deleted file mode 100644
index e69de29b..00000000
diff --git a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run b/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
deleted file mode 100755
index c313d993..00000000
--- a/docs/example/ase/plams_workdir/HH_dzp/HH_dzp.run
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/sh
-
-unset AMS_SWITCH_LOGFILE_AND_STDOUT
-AMS_JOBNAME="HH_dzp" AMS_RESULTSDIR=. $AMSBIN/ams <"HH_dzp.in"
-
diff --git a/docs/example/ase/plams_workdir/logfile b/docs/example/ase/plams_workdir/logfile
deleted file mode 100644
index 4f408ce5..00000000
--- a/docs/example/ase/plams_workdir/logfile
+++ /dev/null
@@ -1,5 +0,0 @@
-[25.02|13:05:17] Running PLAMS located in /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams
-[25.02|13:05:17] Using Python 3.8.0 located in /home/nico/anaconda3/envs/qmctorch/bin/python
-[25.02|13:05:17] PLAMS defaults were loaded from /home/nico/anaconda3/envs/qmctorch/lib/python3.8/site-packages/scm/plams/plams_defaults
-[25.02|13:05:17] PLAMS environment initialized
-[25.02|13:05:17] PLAMS working folder: /home/nico/QMCTorch/docs/example/ase/plams_workdir
diff --git a/docs/example/ase/traj.xyz b/docs/example/ase/traj.xyz
deleted file mode 100644
index e0d228c307881f9364d462cf377a4274a921f896..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2850
zcmeHJeN0<b6t98<SzHiAhGY8jI*@F%d*6MJKYCekpJds>My4RbYk922*AHIXDb$jx
zBS@TVEK7zsH<&~Vo5+G=jxD<k#TmmIjIm^zI3iP-iw2$Bx|l8A*A_I!sO2yI@cr@5
zJzw{p^Lyu<`*fJ21}l|qYqqV`ZCAuv$?SG0^%$0*i9U;BG#nEIV*EXSp)q!j)I^>T
zoD;+rF*(r8tX`M=$Wt)6rA4{5sSy+u1(#g!J_h#<{u0c2wHX!$Ix`<C+y<^(J6mC{
z>H%NG4)o%?B*kTQ*zp34%*SxiB~|_*!D&53>j@kwswJ0Mu{zyRQ!nnWcS^_ycOa3?
z+8{<0$S%f9imF_<v1G04Y!jcabh#y`3keCtTkUR1*(J*Ap+3YrO=h$#uMuUJl#l(H
zR3NS0V>6*3^~l7F+p9%I5$jd+a!S>ry*LIP!g3XntsE|^8q43A=VP?$Q6oFVsE>h)
z_?RVG4W+!C(4**PU&!>|1nO>PQ8s&I5q;)ZfTAq|Or1^r^k$2izf)9@6y>Y};KgOp
zB+2U1?vZ6RXvr=qJJp<Yq@H92k|JoHCIm)ccr{+Mjr5=LL5>wZpHHjR8dLi4p46Fh
zrXxR})|u16hlZ?0z!8GrICmc6k3wTf#>mWD)5cn9x3S3{0{#JK!;5+uR(Y?K6@F6*
zmL1S$cU}4b`p0sDZ`ZAdnqgzmesd*wc=eCe_ZLrrq`CTW#sfIV@Cy-f!a$J>!y9OZ
z<+->J=LA%C2=UoIp1wEQn1TDE6ibTI_T(r{O^MR~-~Wt2>(FC%BKJYaG>$fN**T!&
znL7Dya|q(Cle+4|I=FbLru*slZX3fxrR~#AA&|GSc0%*G1q@IB)Y<{7;fhmh#&WNo
zgxHPCJ71T#1I?bpl}*>vKy&+0lH<(#AZ32_OVaFu92p$RZ~}!&nB@%u9ajaD3^6-2
z(A@C1mu?xooDOTm?yI{SR)K`XjDsKbh2XD)5A;1LF>uL|kmrTX3BdA1!>0YcXl|VU
zG;gM*1QhO=`n>pBHN?|`BxyPc3%%bhKDNFL<b64|<G{-<I9ay$PRWJAdE;)N7UbZd
zXqM&$hUNqVMN#qLZZJeg2SQz|wcN;Be!49UezNrqryR})Cw?OmG*cnyzgf`Mk;%jU
z-h*8mGJiOiWz8N>{yGFSM>F2^QZyJZC<@447aaR|H1R_50GvE~dsXXE5n$oe(RW))
zV7b3)*#I>F?w?=1QzXGG$broY951k}LEs1`F4!qj?cm5Asp4MH+1+z#b1Iy2T3%V<
z$pOWaZMXJlC*VtWjs1MB01s{G`u4S@>F_JZvm+OmPXPa&DPQ=E32Hh=-pQ51#>DK6
zy`SyvhyKRl8BI|Y<j3~~!pAG1W$@5*os}o%TkjOZqozcOEwEn`^hbhjJamh*>U|j>
K@T}UxKHu*_92Q&v

diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index c6224752..be30cbdb 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -166,7 +166,7 @@ def __call__(
                     self.nstep / (time() - tstart),
                 )
                 log.info("   Total Time          : {:1.2f} sec.", (time() - tstart))
-                
+
         return torch.cat(pos).requires_grad_()
 
     def configure_move(self, move: Dict):
diff --git a/tests/H2.xyz b/tests/H2.xyz
deleted file mode 100644
index f6a613bb..00000000
--- a/tests/H2.xyz
+++ /dev/null
@@ -1,4 +0,0 @@
-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/tests/solver/test_h2_pyscf_geo_opt.py b/tests/solver/test_h2_pyscf_geo_opt.py
deleted file mode 100644
index d299ab5d..00000000
--- a/tests/solver/test_h2_pyscf_geo_opt.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import unittest
-
-import numpy as np
-import torch
-import torch.optim as optim
-
-
-from qmctorch.sampler import Metropolis
-from qmctorch.scf import Molecule
-from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
-from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
-from qmctorch.solver import Solver
-
-__PLOT__ = True
-
-
-class TestH2GeoOpt(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",
-        )
-
-        # 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)
-
-    # def test_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
-    #     gse = -1.16
-    #     assert e > 2 * gse and e < 0.0
-    #     assert v > 0 and v < 2.0
-
-
-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_pyscf_metropolis.py b/tests/solver/test_h2_pyscf_metropolis.py
index 2fb926fd..b6c1dcc9 100644
--- a/tests/solver/test_h2_pyscf_metropolis.py
+++ b/tests/solver/test_h2_pyscf_metropolis.py
@@ -64,29 +64,6 @@ def setUp(self):
         # values on different arch
         self.expected_variance = [0.9279592633247375, 0.7445300449383236]
 
-    # 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
-    #     gse = -1.16
-    #     assert e > 2 * gse and e < 0.0
-    #     assert v > 0 and v < 2.0
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/traj.xyz b/tests/traj.xyz
deleted file mode 100644
index 1be286dd99b387c3cb3f3cc42edb3d6c0ef613ef..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1104
zcmdN@$WK!U&B=8PcGV3jO3X@4F3B&dR8U}MfB+^a%>Wgsfbtp9XrCaXuQLzn?JtX3
zaqrA33HuY94XUSCT-&eZXO~p0^?jf31&4&4vjy#E@CRlX7hSXOhZ<0=RF+y)oSC1e
zWTjxJqo9;noEnc1Q8LyuGS)Lt0!pN$7AF^F7L-7gRx6cM7Ni38DCGl%ax<$E!4g1q
zP=0C=NHQe9C^^F)q5>!al+I18h%YWlEhq*`8vyy4c_pbuWr;Z;>uZ7hf}~_1Gde9X
zr#Mwd0hx*g%I1~kCIOwR2UJq6l$VlNRFqf=QXXvtk_DP&W&*Ut)GQWkRDN+L$W_>s
z>nIq5bfo3vCqnd?8-evCr{;j15*=-z2Xq~b04gOU05UB(F(<h+ClMHdPzNUFf`h0q
z7Zj<<86f``Bo+Zhfqn)BK($g%Vp3`jh?!TKlT%w;tNiJ2VeZ`7I{Pct?Ht+_)$H@a
zgsaQjukD``y1#x_zW9D4;Z=TZYoFTH3mkCQZoX!}9hwfRl?q7luBnm5;P5XjJv+b?
MIxNAD(&U5y0HwC$<p2Nx


From 4c9a0be62934c7f43ecd524a543c5f3898748f7f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 16:28:24 +0100
Subject: [PATCH 235/286] checkout old files

---
 .../wavefunction/jastrows/graph/__init__.py   |   4 +
 .../jastrows/graph/egnn/__init__.py           |   0
 .../wavefunction/jastrows/graph/egnn/egnn.py  |  88 +++++
 .../wavefunction/jastrows/graph/egnn/gcl.py   | 351 ++++++++++++++++++
 .../jastrows/graph/elec_elec_graph.py         |  45 +++
 .../jastrows/graph/elec_nuc_graph.py          |  83 +++++
 .../jastrows/graph/jastrow_graph.py           | 265 +++++++++++++
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 315 ++++++++++++++++
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  97 +++++
 10 files changed, 1248 insertions(+)
 create mode 100644 qmctorch/wavefunction/jastrows/graph/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 create mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py

diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
new file mode 100644
index 00000000..af55bd1c
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -0,0 +1,4 @@
+from .jastrow_graph import JastrowFactorGraph as JastrowFactor
+from .mgcn.mgcn_predictor import MGCNPredictor
+
+__all__ = ["JastrowFactor", "MGCNPredictor"]
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py b/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
new file mode 100644
index 00000000..47e18648
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
@@ -0,0 +1,88 @@
+from models.gcl import E_GCL, unsorted_segment_sum
+import torch
+from torch import nn
+
+
+class E_GCL_mask(E_GCL):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_attr_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False):
+        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_attr_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention)
+
+        del self.coord_mlp
+        self.act_fn = act_fn
+
+    def coord_model(self, coord, edge_index, coord_diff, edge_feat, edge_mask):
+        row, col = edge_index
+        trans = coord_diff * self.coord_mlp(edge_feat) * edge_mask
+        agg = unsorted_segment_sum(trans, row, num_segments=coord.size(0))
+        coord += agg*self.coords_weight
+        return coord
+
+    def forward(self, h, edge_index, coord, node_mask, edge_mask, edge_attr=None, node_attr=None, n_nodes=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+
+        edge_feat = edge_feat * edge_mask
+
+        # TO DO: edge_feat = edge_feat * edge_mask
+
+        #coord = self.coord_model(coord, edge_index, coord_diff, edge_feat, edge_mask)
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+
+        return h, coord, edge_attr
+
+
+
+class EGNN(nn.Module):
+    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, device='cpu', act_fn=nn.SiLU(), n_layers=4, coords_weight=1.0, attention=False, node_attr=1):
+        super(EGNN, self).__init__()
+        self.hidden_nf = hidden_nf
+        self.device = device
+        self.n_layers = n_layers
+
+        ### Encoder
+        self.embedding = nn.Linear(in_node_nf, hidden_nf)
+        self.node_attr = node_attr
+        if node_attr:
+            n_node_attr = in_node_nf
+        else:
+            n_node_attr = 0
+        for i in range(0, n_layers):
+            self.add_module("gcl_%d" % i, E_GCL_mask(self.hidden_nf, self.hidden_nf, self.hidden_nf, edges_in_d=in_edge_nf, nodes_attr_dim=n_node_attr, act_fn=act_fn, recurrent=True, coords_weight=coords_weight, attention=attention))
+
+        self.node_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
+                                      act_fn,
+                                      nn.Linear(self.hidden_nf, self.hidden_nf))
+
+        self.graph_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
+                                       act_fn,
+                                       nn.Linear(self.hidden_nf, 1))
+        self.to(self.device)
+
+    def forward(self, h0, x, edges, edge_attr, node_mask, edge_mask, n_nodes):
+        h = self.embedding(h0)
+        for i in range(0, self.n_layers):
+            if self.node_attr:
+                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr, node_attr=h0, n_nodes=n_nodes)
+            else:
+                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr,
+                                                      node_attr=None, n_nodes=n_nodes)
+
+        h = self.node_dec(h)
+        h = h * node_mask
+        h = h.view(-1, n_nodes, self.hidden_nf)
+        h = torch.sum(h, dim=1)
+        pred = self.graph_dec(h)
+        return pred.squeeze(1)
+
+
+
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
new file mode 100644
index 00000000..3d1aebfd
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
@@ -0,0 +1,351 @@
+from torch import nn
+import torch
+
+class MLP(nn.Module):
+    """ a simple 4-layer MLP """
+
+    def __init__(self, nin, nout, nh):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(nin, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nh),
+            nn.LeakyReLU(0.2),
+            nn.Linear(nh, nout),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class GCL_basic(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self):
+        super(GCL_basic, self).__init__()
+
+
+    def edge_model(self, source, target, edge_attr):
+        pass
+
+    def node_model(self, h, edge_index, edge_attr):
+        pass
+
+    def forward(self, x, edge_index, edge_attr=None):
+        row, col = edge_index
+        edge_feat = self.edge_model(x[row], x[col], edge_attr)
+        x = self.node_model(x, edge_index, edge_feat)
+        return x, edge_feat
+
+
+
+class GCL(GCL_basic):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_nf=0, act_fn=nn.ReLU(), bias=True, attention=False, t_eq=False, recurrent=True):
+        super(GCL, self).__init__()
+        self.attention = attention
+        self.t_eq=t_eq
+        self.recurrent = recurrent
+        input_edge_nf = input_nf * 2
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(input_edge_nf + edges_in_nf, hidden_nf, bias=bias),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf, bias=bias),
+            act_fn)
+        if self.attention:
+            self.att_mlp = nn.Sequential(
+                nn.Linear(input_nf, hidden_nf, bias=bias),
+                act_fn,
+                nn.Linear(hidden_nf, 1, bias=bias),
+                nn.Sigmoid())
+
+
+        self.node_mlp = nn.Sequential(
+            nn.Linear(hidden_nf + input_nf, hidden_nf, bias=bias),
+            act_fn,
+            nn.Linear(hidden_nf, output_nf, bias=bias))
+
+        #if recurrent:
+            #self.gru = nn.GRUCell(hidden_nf, hidden_nf)
+
+
+    def edge_model(self, source, target, edge_attr):
+        edge_in = torch.cat([source, target], dim=1)
+        if edge_attr is not None:
+            edge_in = torch.cat([edge_in, edge_attr], dim=1)
+        out = self.edge_mlp(edge_in)
+        if self.attention:
+            att = self.att_mlp(torch.abs(source - target))
+            out = out * att
+        return out
+
+    def node_model(self, h, edge_index, edge_attr):
+        row, col = edge_index
+        agg = unsorted_segment_sum(edge_attr, row, num_segments=h.size(0))
+        out = torch.cat([h, agg], dim=1)
+        out = self.node_mlp(out)
+        if self.recurrent:
+            out = out + h
+            #out = self.gru(out, h)
+        return out
+
+
+class GCL_rf(GCL_basic):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, nf=64, edge_attr_nf=0, reg=0, act_fn=nn.LeakyReLU(0.2), clamp=False):
+        super(GCL_rf, self).__init__()
+
+        self.clamp = clamp
+        layer = nn.Linear(nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+        self.phi = nn.Sequential(nn.Linear(edge_attr_nf + 1, nf),
+                                 act_fn,
+                                 layer)
+        self.reg = reg
+
+    def edge_model(self, source, target, edge_attr):
+        x_diff = source - target
+        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
+        e_input = torch.cat([radial, edge_attr], dim=1)
+        e_out = self.phi(e_input)
+        m_ij = x_diff * e_out
+        if self.clamp:
+            m_ij = torch.clamp(m_ij, min=-100, max=100)
+        return m_ij
+
+    def node_model(self, x, edge_index, edge_attr):
+        row, col = edge_index
+        agg = unsorted_segment_mean(edge_attr, row, num_segments=x.size(0))
+        x_out = x + agg - x*self.reg
+        return x_out
+
+
+class E_GCL(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, clamp=False, norm_diff=False, tanh=False):
+        super(E_GCL, self).__init__()
+        input_edge = input_nf * 2
+        self.coords_weight = coords_weight
+        self.recurrent = recurrent
+        self.attention = attention
+        self.norm_diff = norm_diff
+        self.tanh = tanh
+        edge_coords_nf = 1
+
+
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(input_edge + edge_coords_nf + edges_in_d, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf),
+            act_fn)
+
+        self.node_mlp = nn.Sequential(
+            nn.Linear(hidden_nf + input_nf + nodes_att_dim, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, output_nf))
+
+        layer = nn.Linear(hidden_nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+
+        self.clamp = clamp
+        coord_mlp = []
+        coord_mlp.append(nn.Linear(hidden_nf, hidden_nf))
+        coord_mlp.append(act_fn)
+        coord_mlp.append(layer)
+        if self.tanh:
+            coord_mlp.append(nn.Tanh())
+            self.coords_range = nn.Parameter(torch.ones(1))*3
+        self.coord_mlp = nn.Sequential(*coord_mlp)
+
+
+        if self.attention:
+            self.att_mlp = nn.Sequential(
+                nn.Linear(hidden_nf, 1),
+                nn.Sigmoid())
+
+        #if recurrent:
+        #    self.gru = nn.GRUCell(hidden_nf, hidden_nf)
+
+
+    def edge_model(self, source, target, radial, edge_attr):
+        if edge_attr is None:  # Unused.
+            out = torch.cat([source, target, radial], dim=1)
+        else:
+            out = torch.cat([source, target, radial, edge_attr], dim=1)
+        out = self.edge_mlp(out)
+        if self.attention:
+            att_val = self.att_mlp(out)
+            out = out * att_val
+        return out
+
+    def node_model(self, x, edge_index, edge_attr, node_attr):
+        row, col = edge_index
+        agg = unsorted_segment_sum(edge_attr, row, num_segments=x.size(0))
+        if node_attr is not None:
+            agg = torch.cat([x, agg, node_attr], dim=1)
+        else:
+            agg = torch.cat([x, agg], dim=1)
+        out = self.node_mlp(agg)
+        if self.recurrent:
+            out = x + out
+        return out, agg
+
+    def coord_model(self, coord, edge_index, coord_diff, edge_feat):
+        row, col = edge_index
+        trans = coord_diff * self.coord_mlp(edge_feat)
+        trans = torch.clamp(trans, min=-100, max=100) #This is never activated but just in case it case it explosed it may save the train
+        agg = unsorted_segment_mean(trans, row, num_segments=coord.size(0))
+        coord += agg*self.coords_weight
+        return coord
+
+
+    def coord2radial(self, edge_index, coord):
+        row, col = edge_index
+        coord_diff = coord[row] - coord[col]
+        radial = torch.sum((coord_diff)**2, 1).unsqueeze(1)
+
+        if self.norm_diff:
+            norm = torch.sqrt(radial) + 1
+            coord_diff = coord_diff/(norm)
+
+        return radial, coord_diff
+
+    def forward(self, h, edge_index, coord, edge_attr=None, node_attr=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+        # coord = self.node_coord_model(h, coord)
+        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
+        return h, coord, edge_attr
+
+
+class E_GCL_vel(E_GCL):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+
+
+    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, norm_diff=False, tanh=False):
+        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_att_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention, norm_diff=norm_diff, tanh=tanh)
+        self.norm_diff = norm_diff
+        self.coord_mlp_vel = nn.Sequential(
+            nn.Linear(input_nf, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, 1))
+
+    def forward(self, h, edge_index, coord, vel, edge_attr=None, node_attr=None):
+        row, col = edge_index
+        radial, coord_diff = self.coord2radial(edge_index, coord)
+
+        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
+        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
+
+
+        coord += self.coord_mlp_vel(h) * vel
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+        # coord = self.node_coord_model(h, coord)
+        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
+        return h, coord, edge_attr
+
+
+
+
+class GCL_rf_vel(nn.Module):
+    """Graph Neural Net with global state and fixed number of nodes per graph.
+    Args:
+          hidden_dim: Number of hidden units.
+          num_nodes: Maximum number of nodes (for self-attentive pooling).
+          global_agg: Global aggregation function ('attn' or 'sum').
+          temp: Softmax temperature.
+    """
+    def __init__(self,  nf=64, edge_attr_nf=0, act_fn=nn.LeakyReLU(0.2), coords_weight=1.0):
+        super(GCL_rf_vel, self).__init__()
+        self.coords_weight = coords_weight
+        self.coord_mlp_vel = nn.Sequential(
+            nn.Linear(1, nf),
+            act_fn,
+            nn.Linear(nf, 1))
+
+        layer = nn.Linear(nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+        #layer.weight.uniform_(-0.1, 0.1)
+        self.phi = nn.Sequential(nn.Linear(1 + edge_attr_nf, nf),
+                                 act_fn,
+                                 layer,
+                                 nn.Tanh()) #we had to add the tanh to keep this method stable
+
+    def forward(self, x, vel_norm, vel, edge_index, edge_attr=None):
+        row, col = edge_index
+        edge_m = self.edge_model(x[row], x[col], edge_attr)
+        x = self.node_model(x, edge_index, edge_m)
+        x += vel * self.coord_mlp_vel(vel_norm)
+        return x, edge_attr
+
+    def edge_model(self, source, target, edge_attr):
+        x_diff = source - target
+        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
+        e_input = torch.cat([radial, edge_attr], dim=1)
+        e_out = self.phi(e_input)
+        m_ij = x_diff * e_out
+        return m_ij
+
+    def node_model(self, x, edge_index, edge_m):
+        row, col = edge_index
+        agg = unsorted_segment_mean(edge_m, row, num_segments=x.size(0))
+        x_out = x + agg * self.coords_weight
+        return x_out
+
+
+def unsorted_segment_sum(data, segment_ids, num_segments):
+    """Custom PyTorch op to replicate TensorFlow's `unsorted_segment_sum`."""
+    result_shape = (num_segments, data.size(1))
+    result = data.new_full(result_shape, 0)  # Init empty result tensor.
+    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
+    result.scatter_add_(0, segment_ids, data)
+    return result
+
+
+def unsorted_segment_mean(data, segment_ids, num_segments):
+    result_shape = (num_segments, data.size(1))
+    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
+    result = data.new_full(result_shape, 0)  # Init empty result tensor.
+    count = data.new_full(result_shape, 0)
+    result.scatter_add_(0, segment_ids, data)
+    count.scatter_add_(0, segment_ids, torch.ones_like(data))
+    return result / count.clamp(min=1)
\ 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..35a8f7f9
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -0,0 +1,45 @@
+import dgl
+import torch
+
+
+def ElecElecGraph(nelec, nup):
+    """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):
+    """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, nup):
+    """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..0cb22dc8
--- /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, atom_types, atomic_features, nelec, nup):
+    """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, nelec):
+    """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, atom_types, atomic_features, nelec, nup):
+    """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, atomic_features):
+    """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/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
new file mode 100644
index 00000000..a2c409c1
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
@@ -0,0 +1,265 @@
+import torch
+from torch import nn
+from torch.autograd import grad
+import dgl
+
+from .mgcn.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
+
+
+class JastrowFactorGraph(nn.Module):
+    def __init__(
+        self,
+        mol,
+        ee_model=MGCNPredictor,
+        ee_model_kwargs={},
+        en_model=MGCNPredictor,
+        en_model_kwargs={},
+        atomic_features=["atomic_number"],
+        cuda=False,
+    ):
+        """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 = ee_model(**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 = en_model(**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 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) 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, en_kernel):
+        """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, ee_kernel, en_kernel, sum_grad):
+        """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, ee_kernel, en_kernel, sum_grad=False, return_all=False
+    ):
+        """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):
+        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):
+        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):
+        """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/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
new file mode 100644
index 00000000..4b69b18e
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import dgl.function as fn
+import torch
+import torch.nn as nn
+
+from dgllife.model.gnn.schnet import RBFExpansion
+
+
+class EdgeEmbedding(nn.Module):
+    """Module for embedding edges.
+
+    Edges whose end nodes have the same combination of types
+    share the same initial embedding.
+
+    Parameters
+    ----------
+    num_types : int
+        Number of edge types to embed.
+    edge_feats : int
+        Size for the edge representations to learn.
+    """
+
+    def __init__(self, num_types, edge_feats):
+        super(EdgeEmbedding, self).__init__()
+        self.embed = nn.Embedding(num_types, edge_feats)
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.embed.reset_parameters()
+
+    def get_edge_types(self, edges):
+        """Generates edge types.
+
+        The edge type is based on the type of the source and destination nodes.
+        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
+
+        To map each pair of node types to a unique number, we use an unordered pairing function.
+        See more details in this discussion:
+        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
+        Note that the number of edge types should be larger than the square of the maximum node
+        type in the dataset.
+
+        Parameters
+        ----------
+        edges : EdgeBatch
+            Container for a batch of edges.
+
+        Returns
+        -------
+        dict
+            Mapping 'type' to the computed edge types.
+        """
+        node_type1 = edges.src["type"]
+        node_type2 = edges.dst["type"]
+        return {
+            "type": node_type1 * node_type2
+            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
+        }
+
+    def forward(self, g, node_types):
+        """Embeds edge types.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+
+        Returns
+        -------
+        float32 tensor of shape (E, edge_feats)
+            Edge representations.
+        """
+        g = g.local_var()
+        g.ndata["type"] = node_types
+        g.apply_edges(self.get_edge_types)
+        return self.embed(g.edata["type"])
+
+
+class VEConv(nn.Module):
+    """Vertex-Edge Convolution in MGCN
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This layer combines both node and edge features in updating node representations.
+
+    Parameters
+    ----------
+    dist_feats : int
+        Size for the expanded distances.
+    feats : int
+        Size for the input and output node and edge representations.
+    update_edge : bool
+        Whether to update edge representations. Default to True.
+    """
+
+    def __init__(self, dist_feats, feats, update_edge=True):
+        super(VEConv, self).__init__()
+
+        self.update_dists = nn.Sequential(
+            nn.Linear(dist_feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats),
+        )
+        if update_edge:
+            self.update_edge_feats = nn.Linear(feats, feats)
+        else:
+            self.update_edge_feats = None
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        for layer in self.update_dists:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+
+        if self.update_edge_feats is not None:
+            self.update_edge_feats.reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features.
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Edge representations, updated if ``update_edge == True`` in initialization.
+        """
+        expanded_dists = self.update_dists(expanded_dists)
+        if self.update_edge_feats is not None:
+            edge_feats = self.update_edge_feats(edge_feats)
+
+        g = g.local_var()
+        g.ndata.update({"hv": node_feats})
+        g.edata.update({"dist": expanded_dists, "he": edge_feats})
+        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
+        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
+        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
+
+        return node_feats, edge_feats
+
+
+class MultiLevelInteraction(nn.Module):
+    """Building block for MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
+    edge features and expanded distances in message passing and updates node and edge
+    representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the input and output node and edge representations.
+    dist_feats : int
+        Size for the expanded distances.
+    """
+
+    def __init__(self, feats, dist_feats):
+        super(MultiLevelInteraction, self).__init__()
+
+        self.project_in_node_feats = nn.Linear(feats, feats)
+        self.conv = VEConv(dist_feats, feats)
+        self.project_out_node_feats = nn.Sequential(
+            nn.Linear(feats, feats),
+            nn.Softplus(beta=0.5, threshold=14),
+            nn.Linear(feats, feats),
+        )
+        self.project_edge_feats = nn.Sequential(
+            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
+        )
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.project_in_node_feats.reset_parameters()
+        self.conv.reset_parameters()
+        for layer in self.project_out_node_feats:
+            if isinstance(layer, nn.Linear):
+                layer.reset_parameters()
+        self.project_edge_feats[0].reset_parameters()
+
+    def forward(self, g, node_feats, edge_feats, expanded_dists):
+        """Performs message passing and updates node and edge representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_feats : float32 tensor of shape (V, feats)
+            Input node features.
+        edge_feats : float32 tensor of shape (E, feats)
+            Input edge features
+        expanded_dists : float32 tensor of shape (E, dist_feats)
+            Expanded distances, i.e. the output of RBFExpansion.
+
+        Returns
+        -------
+        node_feats : float32 tensor of shape (V, feats)
+            Updated node representations.
+        edge_feats : float32 tensor of shape (E, feats)
+            Updated edge representations.
+        """
+        new_node_feats = self.project_in_node_feats(node_feats)
+        new_node_feats, edge_feats = self.conv(
+            g, new_node_feats, edge_feats, expanded_dists
+        )
+        new_node_feats = self.project_out_node_feats(new_node_feats)
+        node_feats = node_feats + new_node_feats
+
+        edge_feats = self.project_edge_feats(edge_feats)
+
+        return node_feats, edge_feats
+
+
+class MGCNGNN(nn.Module):
+    """MGCN.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    This class performs message passing in MGCN and returns the updated node representations.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 30.
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 0.1.
+    """
+
+    def __init__(  # pylint: disable=to-many-arguments
+        self,
+        feats=128,
+        n_layers=3,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=30.0,
+        gap=0.1,
+    ):
+        super(MGCNGNN, self).__init__()
+
+        self.node_embed = nn.Embedding(num_node_types, feats)
+        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
+        self.high = cutoff
+        self.gap = gap
+        self.rbf = RBFExpansion(high=cutoff, gap=gap)
+
+        self.gnn_layers = nn.ModuleList()
+        for _ in range(n_layers):
+            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
+
+    def reset_parameters(self):
+        """Reinitialize model parameters."""
+        self.node_embed.reset_parameters()
+        self.edge_embed.reset_parameters()
+        self.rbf.reset_parameters()
+
+        for layer in self.gnn_layers:
+            layer.reset_parameters()
+
+    def forward(self, g, node_types, edge_dists):
+        """Performs message passing and updates node representations.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (V, feats * (n_layers + 1))
+            Output node representations.
+        """
+
+        node_feats = self.node_embed(node_types)
+        edge_feats = self.edge_embed(g, node_types)
+        expanded_dists = self.rbf(edge_dists)
+
+        all_layer_node_feats = [node_feats]
+        for gnn in self.gnn_layers:
+            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
+            all_layer_node_feats.append(node_feats)
+        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
new file mode 100644
index 00000000..9f710fd3
--- /dev/null
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# MGCN
+# pylint: disable= no-member, arguments-differ, invalid-name
+
+import torch.nn as nn
+from dgllife.model.readout import MLPNodeReadout
+from .mgcn import MGCNGNN
+
+
+class MGCNPredictor(nn.Module):
+    """MGCN for for regression and classification on graphs.
+
+    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
+    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
+
+    Parameters
+    ----------
+    feats : int
+        Size for the node and edge embeddings to learn. Default to 128.
+    n_layers : int
+        Number of gnn layers to use. Default to 3.
+    classifier_hidden_feats : int
+        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
+        representations in the classifier. Default to 64.
+    n_tasks : int
+        Number of tasks, which is also the output size. Default to 1.
+    num_node_types : int
+        Number of node types to embed. Default to 100.
+    num_edge_types : int
+        Number of edge types to embed. Default to 3000.
+    cutoff : float
+        Largest center in RBF expansion. Default to 5.0
+    gap : float
+        Difference between two adjacent centers in RBF expansion. Default to 1.0
+    predictor_hidden_feats : int
+        Size for hidden representations in the output MLP predictor. Default to 64.
+    """
+
+    def __init__(
+        self,
+        feats=128,
+        n_layers=3,
+        classifier_hidden_feats=64,
+        n_tasks=1,
+        num_node_types=100,
+        num_edge_types=3000,
+        cutoff=5.0,
+        gap=1.0,
+        predictor_hidden_feats=64,
+    ):
+        super(MGCNPredictor, self).__init__()
+
+        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
+            print(
+                "classifier_hidden_feats is deprecated and will be removed in the future, "
+                "use predictor_hidden_feats instead"
+            )
+            predictor_hidden_feats = classifier_hidden_feats
+
+        self.gnn = MGCNGNN(
+            feats=feats,
+            n_layers=n_layers,
+            num_node_types=num_node_types,
+            num_edge_types=num_edge_types,
+            cutoff=cutoff,
+            gap=gap,
+        )
+        self.readout = MLPNodeReadout(
+            node_feats=(n_layers + 1) * feats,
+            hidden_feats=predictor_hidden_feats,
+            graph_feats=n_tasks,
+            activation=nn.Softplus(beta=1, threshold=20),
+        )
+
+    def forward(self, g, node_types, edge_dists):
+        """Graph-level regression/soft classification.
+
+        Parameters
+        ----------
+        g : DGLGraph
+            DGLGraph for a batch of graphs.
+        node_types : int64 tensor of shape (V)
+            Node types to embed, V for the number of nodes.
+        edge_dists : float32 tensor of shape (E, 1)
+            Distances between end nodes of edges, E for the number of edges.
+
+        Returns
+        -------
+        float32 tensor of shape (G, n_tasks)
+            Prediction for the graphs in the batch. G for the number of graphs.
+        """
+        node_feats = self.gnn(g, node_types, edge_dists)
+        return self.readout(g, node_feats)

From 22b05478058f32402f52c6b8e3f63cb8a87a3508 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 25 Feb 2025 17:24:33 +0100
Subject: [PATCH 236/286] fix

---
 .github/workflows/build.yml                   |   4 +
 docs/example/jast_graph.py                    |  19 +++
 setup.py                                      |   2 +-
 tests/wavefunction/jastrows/graph/__init__.py |   0
 .../jastrows/graph/test_graph_jastrow.py      | 114 ++++++++++++++++++
 5 files changed, 138 insertions(+), 1 deletion(-)
 create mode 100644 docs/example/jast_graph.py
 create mode 100644 tests/wavefunction/jastrows/graph/__init__.py
 create mode 100644 tests/wavefunction/jastrows/graph/test_graph_jastrow.py

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9eacd168..111892e0 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -30,6 +30,10 @@ jobs:
       run: |
         sudo apt update
         sudo apt install build-essential pandoc
+    - name: Install specific packages
+      run: |
+        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,doc]
       env:
diff --git a/docs/example/jast_graph.py b/docs/example/jast_graph.py
new file mode 100644
index 00000000..4df30937
--- /dev/null
+++ b/docs/example/jast_graph.py
@@ -0,0 +1,19 @@
+
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+import torch
+from torch.autograd import grad
+nup = 2
+ndown = 2
+atomic_pos = torch.rand(2, 3)
+atom_types = ["Li", "H"]
+jast = JastrowFactorGraph(nup, ndown,
+                          atomic_pos,
+                          atom_types)
+
+
+pos = torch.rand(10, 12)
+pos.requires_grad = True
+jval = jast(pos)
+
+gval = jast(pos, derivative=1)
+hval = jast(pos, derivative=2)
diff --git a/setup.py b/setup.py
index 7dfb002c..7a354a1c 100644
--- a/setup.py
+++ b/setup.py
@@ -44,7 +44,7 @@
                       'scipy', 'tqdm', 'torch', 'h5py',
                       'plams', 'pints', 'linetimer',
                       'pyscf', 'mendeleev', 'twiggy',
-                      'plams', 'ase'],
+                      'plams', 'ase', 'rdkit', 'dgllife', 'dgl'],
 
     extras_require={
         'hpc': ['horovod'],
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..67ac08ab
--- /dev/null
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -0,0 +1,114 @@
+import unittest
+import numpy as np
+import torch
+from torch.autograd import Variable, grad
+from types import SimpleNamespace
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+
+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 = JastrowFactorGraph(
+            self.mol,
+            ee_model=MGCNPredictor,
+            ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
+            en_model=MGCNPredictor,
+            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()

From a0849af472afb3f42d7ece1d328082388a5f94c5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 09:47:36 +0100
Subject: [PATCH 237/286] remvoed egnn

---
 .../jastrows/graph/egnn/__init__.py           |   0
 .../wavefunction/jastrows/graph/egnn/egnn.py  |  88 -----
 .../wavefunction/jastrows/graph/egnn/gcl.py   | 351 ------------------
 3 files changed, 439 deletions(-)
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/egnn/gcl.py

diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py b/qmctorch/wavefunction/jastrows/graph/egnn/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py b/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
deleted file mode 100644
index 47e18648..00000000
--- a/qmctorch/wavefunction/jastrows/graph/egnn/egnn.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from models.gcl import E_GCL, unsorted_segment_sum
-import torch
-from torch import nn
-
-
-class E_GCL_mask(E_GCL):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_attr_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False):
-        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_attr_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention)
-
-        del self.coord_mlp
-        self.act_fn = act_fn
-
-    def coord_model(self, coord, edge_index, coord_diff, edge_feat, edge_mask):
-        row, col = edge_index
-        trans = coord_diff * self.coord_mlp(edge_feat) * edge_mask
-        agg = unsorted_segment_sum(trans, row, num_segments=coord.size(0))
-        coord += agg*self.coords_weight
-        return coord
-
-    def forward(self, h, edge_index, coord, node_mask, edge_mask, edge_attr=None, node_attr=None, n_nodes=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-
-        edge_feat = edge_feat * edge_mask
-
-        # TO DO: edge_feat = edge_feat * edge_mask
-
-        #coord = self.coord_model(coord, edge_index, coord_diff, edge_feat, edge_mask)
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-
-        return h, coord, edge_attr
-
-
-
-class EGNN(nn.Module):
-    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, device='cpu', act_fn=nn.SiLU(), n_layers=4, coords_weight=1.0, attention=False, node_attr=1):
-        super(EGNN, self).__init__()
-        self.hidden_nf = hidden_nf
-        self.device = device
-        self.n_layers = n_layers
-
-        ### Encoder
-        self.embedding = nn.Linear(in_node_nf, hidden_nf)
-        self.node_attr = node_attr
-        if node_attr:
-            n_node_attr = in_node_nf
-        else:
-            n_node_attr = 0
-        for i in range(0, n_layers):
-            self.add_module("gcl_%d" % i, E_GCL_mask(self.hidden_nf, self.hidden_nf, self.hidden_nf, edges_in_d=in_edge_nf, nodes_attr_dim=n_node_attr, act_fn=act_fn, recurrent=True, coords_weight=coords_weight, attention=attention))
-
-        self.node_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
-                                      act_fn,
-                                      nn.Linear(self.hidden_nf, self.hidden_nf))
-
-        self.graph_dec = nn.Sequential(nn.Linear(self.hidden_nf, self.hidden_nf),
-                                       act_fn,
-                                       nn.Linear(self.hidden_nf, 1))
-        self.to(self.device)
-
-    def forward(self, h0, x, edges, edge_attr, node_mask, edge_mask, n_nodes):
-        h = self.embedding(h0)
-        for i in range(0, self.n_layers):
-            if self.node_attr:
-                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr, node_attr=h0, n_nodes=n_nodes)
-            else:
-                h, _, _ = self._modules["gcl_%d" % i](h, edges, x, node_mask, edge_mask, edge_attr=edge_attr,
-                                                      node_attr=None, n_nodes=n_nodes)
-
-        h = self.node_dec(h)
-        h = h * node_mask
-        h = h.view(-1, n_nodes, self.hidden_nf)
-        h = torch.sum(h, dim=1)
-        pred = self.graph_dec(h)
-        return pred.squeeze(1)
-
-
-
diff --git a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py b/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
deleted file mode 100644
index 3d1aebfd..00000000
--- a/qmctorch/wavefunction/jastrows/graph/egnn/gcl.py
+++ /dev/null
@@ -1,351 +0,0 @@
-from torch import nn
-import torch
-
-class MLP(nn.Module):
-    """ a simple 4-layer MLP """
-
-    def __init__(self, nin, nout, nh):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(nin, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nh),
-            nn.LeakyReLU(0.2),
-            nn.Linear(nh, nout),
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-class GCL_basic(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self):
-        super(GCL_basic, self).__init__()
-
-
-    def edge_model(self, source, target, edge_attr):
-        pass
-
-    def node_model(self, h, edge_index, edge_attr):
-        pass
-
-    def forward(self, x, edge_index, edge_attr=None):
-        row, col = edge_index
-        edge_feat = self.edge_model(x[row], x[col], edge_attr)
-        x = self.node_model(x, edge_index, edge_feat)
-        return x, edge_feat
-
-
-
-class GCL(GCL_basic):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_nf=0, act_fn=nn.ReLU(), bias=True, attention=False, t_eq=False, recurrent=True):
-        super(GCL, self).__init__()
-        self.attention = attention
-        self.t_eq=t_eq
-        self.recurrent = recurrent
-        input_edge_nf = input_nf * 2
-        self.edge_mlp = nn.Sequential(
-            nn.Linear(input_edge_nf + edges_in_nf, hidden_nf, bias=bias),
-            act_fn,
-            nn.Linear(hidden_nf, hidden_nf, bias=bias),
-            act_fn)
-        if self.attention:
-            self.att_mlp = nn.Sequential(
-                nn.Linear(input_nf, hidden_nf, bias=bias),
-                act_fn,
-                nn.Linear(hidden_nf, 1, bias=bias),
-                nn.Sigmoid())
-
-
-        self.node_mlp = nn.Sequential(
-            nn.Linear(hidden_nf + input_nf, hidden_nf, bias=bias),
-            act_fn,
-            nn.Linear(hidden_nf, output_nf, bias=bias))
-
-        #if recurrent:
-            #self.gru = nn.GRUCell(hidden_nf, hidden_nf)
-
-
-    def edge_model(self, source, target, edge_attr):
-        edge_in = torch.cat([source, target], dim=1)
-        if edge_attr is not None:
-            edge_in = torch.cat([edge_in, edge_attr], dim=1)
-        out = self.edge_mlp(edge_in)
-        if self.attention:
-            att = self.att_mlp(torch.abs(source - target))
-            out = out * att
-        return out
-
-    def node_model(self, h, edge_index, edge_attr):
-        row, col = edge_index
-        agg = unsorted_segment_sum(edge_attr, row, num_segments=h.size(0))
-        out = torch.cat([h, agg], dim=1)
-        out = self.node_mlp(out)
-        if self.recurrent:
-            out = out + h
-            #out = self.gru(out, h)
-        return out
-
-
-class GCL_rf(GCL_basic):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, nf=64, edge_attr_nf=0, reg=0, act_fn=nn.LeakyReLU(0.2), clamp=False):
-        super(GCL_rf, self).__init__()
-
-        self.clamp = clamp
-        layer = nn.Linear(nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-        self.phi = nn.Sequential(nn.Linear(edge_attr_nf + 1, nf),
-                                 act_fn,
-                                 layer)
-        self.reg = reg
-
-    def edge_model(self, source, target, edge_attr):
-        x_diff = source - target
-        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
-        e_input = torch.cat([radial, edge_attr], dim=1)
-        e_out = self.phi(e_input)
-        m_ij = x_diff * e_out
-        if self.clamp:
-            m_ij = torch.clamp(m_ij, min=-100, max=100)
-        return m_ij
-
-    def node_model(self, x, edge_index, edge_attr):
-        row, col = edge_index
-        agg = unsorted_segment_mean(edge_attr, row, num_segments=x.size(0))
-        x_out = x + agg - x*self.reg
-        return x_out
-
-
-class E_GCL(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, clamp=False, norm_diff=False, tanh=False):
-        super(E_GCL, self).__init__()
-        input_edge = input_nf * 2
-        self.coords_weight = coords_weight
-        self.recurrent = recurrent
-        self.attention = attention
-        self.norm_diff = norm_diff
-        self.tanh = tanh
-        edge_coords_nf = 1
-
-
-        self.edge_mlp = nn.Sequential(
-            nn.Linear(input_edge + edge_coords_nf + edges_in_d, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, hidden_nf),
-            act_fn)
-
-        self.node_mlp = nn.Sequential(
-            nn.Linear(hidden_nf + input_nf + nodes_att_dim, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, output_nf))
-
-        layer = nn.Linear(hidden_nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-
-        self.clamp = clamp
-        coord_mlp = []
-        coord_mlp.append(nn.Linear(hidden_nf, hidden_nf))
-        coord_mlp.append(act_fn)
-        coord_mlp.append(layer)
-        if self.tanh:
-            coord_mlp.append(nn.Tanh())
-            self.coords_range = nn.Parameter(torch.ones(1))*3
-        self.coord_mlp = nn.Sequential(*coord_mlp)
-
-
-        if self.attention:
-            self.att_mlp = nn.Sequential(
-                nn.Linear(hidden_nf, 1),
-                nn.Sigmoid())
-
-        #if recurrent:
-        #    self.gru = nn.GRUCell(hidden_nf, hidden_nf)
-
-
-    def edge_model(self, source, target, radial, edge_attr):
-        if edge_attr is None:  # Unused.
-            out = torch.cat([source, target, radial], dim=1)
-        else:
-            out = torch.cat([source, target, radial, edge_attr], dim=1)
-        out = self.edge_mlp(out)
-        if self.attention:
-            att_val = self.att_mlp(out)
-            out = out * att_val
-        return out
-
-    def node_model(self, x, edge_index, edge_attr, node_attr):
-        row, col = edge_index
-        agg = unsorted_segment_sum(edge_attr, row, num_segments=x.size(0))
-        if node_attr is not None:
-            agg = torch.cat([x, agg, node_attr], dim=1)
-        else:
-            agg = torch.cat([x, agg], dim=1)
-        out = self.node_mlp(agg)
-        if self.recurrent:
-            out = x + out
-        return out, agg
-
-    def coord_model(self, coord, edge_index, coord_diff, edge_feat):
-        row, col = edge_index
-        trans = coord_diff * self.coord_mlp(edge_feat)
-        trans = torch.clamp(trans, min=-100, max=100) #This is never activated but just in case it case it explosed it may save the train
-        agg = unsorted_segment_mean(trans, row, num_segments=coord.size(0))
-        coord += agg*self.coords_weight
-        return coord
-
-
-    def coord2radial(self, edge_index, coord):
-        row, col = edge_index
-        coord_diff = coord[row] - coord[col]
-        radial = torch.sum((coord_diff)**2, 1).unsqueeze(1)
-
-        if self.norm_diff:
-            norm = torch.sqrt(radial) + 1
-            coord_diff = coord_diff/(norm)
-
-        return radial, coord_diff
-
-    def forward(self, h, edge_index, coord, edge_attr=None, node_attr=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-        # coord = self.node_coord_model(h, coord)
-        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
-        return h, coord, edge_attr
-
-
-class E_GCL_vel(E_GCL):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-
-
-    def __init__(self, input_nf, output_nf, hidden_nf, edges_in_d=0, nodes_att_dim=0, act_fn=nn.ReLU(), recurrent=True, coords_weight=1.0, attention=False, norm_diff=False, tanh=False):
-        E_GCL.__init__(self, input_nf, output_nf, hidden_nf, edges_in_d=edges_in_d, nodes_att_dim=nodes_att_dim, act_fn=act_fn, recurrent=recurrent, coords_weight=coords_weight, attention=attention, norm_diff=norm_diff, tanh=tanh)
-        self.norm_diff = norm_diff
-        self.coord_mlp_vel = nn.Sequential(
-            nn.Linear(input_nf, hidden_nf),
-            act_fn,
-            nn.Linear(hidden_nf, 1))
-
-    def forward(self, h, edge_index, coord, vel, edge_attr=None, node_attr=None):
-        row, col = edge_index
-        radial, coord_diff = self.coord2radial(edge_index, coord)
-
-        edge_feat = self.edge_model(h[row], h[col], radial, edge_attr)
-        coord = self.coord_model(coord, edge_index, coord_diff, edge_feat)
-
-
-        coord += self.coord_mlp_vel(h) * vel
-        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
-        # coord = self.node_coord_model(h, coord)
-        # x = self.node_model(x, edge_index, x[col], u, batch)  # GCN
-        return h, coord, edge_attr
-
-
-
-
-class GCL_rf_vel(nn.Module):
-    """Graph Neural Net with global state and fixed number of nodes per graph.
-    Args:
-          hidden_dim: Number of hidden units.
-          num_nodes: Maximum number of nodes (for self-attentive pooling).
-          global_agg: Global aggregation function ('attn' or 'sum').
-          temp: Softmax temperature.
-    """
-    def __init__(self,  nf=64, edge_attr_nf=0, act_fn=nn.LeakyReLU(0.2), coords_weight=1.0):
-        super(GCL_rf_vel, self).__init__()
-        self.coords_weight = coords_weight
-        self.coord_mlp_vel = nn.Sequential(
-            nn.Linear(1, nf),
-            act_fn,
-            nn.Linear(nf, 1))
-
-        layer = nn.Linear(nf, 1, bias=False)
-        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
-        #layer.weight.uniform_(-0.1, 0.1)
-        self.phi = nn.Sequential(nn.Linear(1 + edge_attr_nf, nf),
-                                 act_fn,
-                                 layer,
-                                 nn.Tanh()) #we had to add the tanh to keep this method stable
-
-    def forward(self, x, vel_norm, vel, edge_index, edge_attr=None):
-        row, col = edge_index
-        edge_m = self.edge_model(x[row], x[col], edge_attr)
-        x = self.node_model(x, edge_index, edge_m)
-        x += vel * self.coord_mlp_vel(vel_norm)
-        return x, edge_attr
-
-    def edge_model(self, source, target, edge_attr):
-        x_diff = source - target
-        radial = torch.sqrt(torch.sum(x_diff ** 2, dim=1)).unsqueeze(1)
-        e_input = torch.cat([radial, edge_attr], dim=1)
-        e_out = self.phi(e_input)
-        m_ij = x_diff * e_out
-        return m_ij
-
-    def node_model(self, x, edge_index, edge_m):
-        row, col = edge_index
-        agg = unsorted_segment_mean(edge_m, row, num_segments=x.size(0))
-        x_out = x + agg * self.coords_weight
-        return x_out
-
-
-def unsorted_segment_sum(data, segment_ids, num_segments):
-    """Custom PyTorch op to replicate TensorFlow's `unsorted_segment_sum`."""
-    result_shape = (num_segments, data.size(1))
-    result = data.new_full(result_shape, 0)  # Init empty result tensor.
-    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
-    result.scatter_add_(0, segment_ids, data)
-    return result
-
-
-def unsorted_segment_mean(data, segment_ids, num_segments):
-    result_shape = (num_segments, data.size(1))
-    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
-    result = data.new_full(result_shape, 0)  # Init empty result tensor.
-    count = data.new_full(result_shape, 0)
-    result.scatter_add_(0, segment_ids, data)
-    count.scatter_add_(0, segment_ids, torch.ones_like(data))
-    return result / count.clamp(min=1)
\ No newline at end of file

From 1c36a205e15de7b421d752fe9be49a4375c7963f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 10:36:56 +0100
Subject: [PATCH 238/286] clean up

---
 docs/example/jast_graph.py                    |  22 +-
 .../wavefunction/jastrows/graph/__init__.py   |   5 +-
 .../jastrows/graph/mgcn/__init__.py           |   0
 .../wavefunction/jastrows/graph/mgcn/mgcn.py  | 315 ------------------
 .../jastrows/graph/mgcn/mgcn_predictor.py     |  97 ------
 .../{jastrow_graph.py => mgcn_jastrow.py}     |  10 +-
 .../jastrows/graph/test_graph_jastrow.py      |   7 +-
 7 files changed, 26 insertions(+), 430 deletions(-)
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
 delete mode 100644 qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
 rename qmctorch/wavefunction/jastrows/graph/{jastrow_graph.py => mgcn_jastrow.py} (97%)

diff --git a/docs/example/jast_graph.py b/docs/example/jast_graph.py
index 4df30937..f6f3e6f7 100644
--- a/docs/example/jast_graph.py
+++ b/docs/example/jast_graph.py
@@ -1,14 +1,28 @@
 
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
+from qmctorch.wavefunction.jastrows.graph.jastrow_graph 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"]
-jast = JastrowFactorGraph(nup, ndown,
-                          atomic_pos,
-                          atom_types)
+
+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)
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index af55bd1c..5b9df08a 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,4 +1,3 @@
-from .jastrow_graph import JastrowFactorGraph as JastrowFactor
-from .mgcn.mgcn_predictor import MGCNPredictor
+from .mgcn_jastrow import MGCNJastrowFactor
 
-__all__ = ["JastrowFactor", "MGCNPredictor"]
+__all__ = ["MGCNJastrowFactor"]
\ No newline at end of file
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py b/qmctorch/wavefunction/jastrows/graph/mgcn/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
deleted file mode 100644
index 4b69b18e..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import dgl.function as fn
-import torch
-import torch.nn as nn
-
-from dgllife.model.gnn.schnet import RBFExpansion
-
-
-class EdgeEmbedding(nn.Module):
-    """Module for embedding edges.
-
-    Edges whose end nodes have the same combination of types
-    share the same initial embedding.
-
-    Parameters
-    ----------
-    num_types : int
-        Number of edge types to embed.
-    edge_feats : int
-        Size for the edge representations to learn.
-    """
-
-    def __init__(self, num_types, edge_feats):
-        super(EdgeEmbedding, self).__init__()
-        self.embed = nn.Embedding(num_types, edge_feats)
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.embed.reset_parameters()
-
-    def get_edge_types(self, edges):
-        """Generates edge types.
-
-        The edge type is based on the type of the source and destination nodes.
-        Note that directions are not distinguished, e.g. C-O and O-C are the same edge type.
-
-        To map each pair of node types to a unique number, we use an unordered pairing function.
-        See more details in this discussion:
-        https://math.stackexchange.com/questions/23503/create-unique-number-from-2-numbers
-        Note that the number of edge types should be larger than the square of the maximum node
-        type in the dataset.
-
-        Parameters
-        ----------
-        edges : EdgeBatch
-            Container for a batch of edges.
-
-        Returns
-        -------
-        dict
-            Mapping 'type' to the computed edge types.
-        """
-        node_type1 = edges.src["type"]
-        node_type2 = edges.dst["type"]
-        return {
-            "type": node_type1 * node_type2
-            + (torch.abs(node_type1 - node_type2) - 1) ** 2 // 4
-        }
-
-    def forward(self, g, node_types):
-        """Embeds edge types.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-
-        Returns
-        -------
-        float32 tensor of shape (E, edge_feats)
-            Edge representations.
-        """
-        g = g.local_var()
-        g.ndata["type"] = node_types
-        g.apply_edges(self.get_edge_types)
-        return self.embed(g.edata["type"])
-
-
-class VEConv(nn.Module):
-    """Vertex-Edge Convolution in MGCN
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This layer combines both node and edge features in updating node representations.
-
-    Parameters
-    ----------
-    dist_feats : int
-        Size for the expanded distances.
-    feats : int
-        Size for the input and output node and edge representations.
-    update_edge : bool
-        Whether to update edge representations. Default to True.
-    """
-
-    def __init__(self, dist_feats, feats, update_edge=True):
-        super(VEConv, self).__init__()
-
-        self.update_dists = nn.Sequential(
-            nn.Linear(dist_feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        if update_edge:
-            self.update_edge_feats = nn.Linear(feats, feats)
-        else:
-            self.update_edge_feats = None
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        for layer in self.update_dists:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-
-        if self.update_edge_feats is not None:
-            self.update_edge_feats.reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features.
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Edge representations, updated if ``update_edge == True`` in initialization.
-        """
-        expanded_dists = self.update_dists(expanded_dists)
-        if self.update_edge_feats is not None:
-            edge_feats = self.update_edge_feats(edge_feats)
-
-        g = g.local_var()
-        g.ndata.update({"hv": node_feats})
-        g.edata.update({"dist": expanded_dists, "he": edge_feats})
-        g.update_all(fn.u_mul_e("hv", "dist", "m_0"), fn.sum("m_0", "hv_0"))
-        g.update_all(fn.copy_e("he", "m_1"), fn.sum("m_1", "hv_1"))
-        node_feats = g.ndata.pop("hv_0") + g.ndata.pop("hv_1")
-
-        return node_feats, edge_feats
-
-
-class MultiLevelInteraction(nn.Module):
-    """Building block for MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__. This layer combines node features,
-    edge features and expanded distances in message passing and updates node and edge
-    representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the input and output node and edge representations.
-    dist_feats : int
-        Size for the expanded distances.
-    """
-
-    def __init__(self, feats, dist_feats):
-        super(MultiLevelInteraction, self).__init__()
-
-        self.project_in_node_feats = nn.Linear(feats, feats)
-        self.conv = VEConv(dist_feats, feats)
-        self.project_out_node_feats = nn.Sequential(
-            nn.Linear(feats, feats),
-            nn.Softplus(beta=0.5, threshold=14),
-            nn.Linear(feats, feats),
-        )
-        self.project_edge_feats = nn.Sequential(
-            nn.Linear(feats, feats), nn.Softplus(beta=0.5, threshold=14)
-        )
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.project_in_node_feats.reset_parameters()
-        self.conv.reset_parameters()
-        for layer in self.project_out_node_feats:
-            if isinstance(layer, nn.Linear):
-                layer.reset_parameters()
-        self.project_edge_feats[0].reset_parameters()
-
-    def forward(self, g, node_feats, edge_feats, expanded_dists):
-        """Performs message passing and updates node and edge representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_feats : float32 tensor of shape (V, feats)
-            Input node features.
-        edge_feats : float32 tensor of shape (E, feats)
-            Input edge features
-        expanded_dists : float32 tensor of shape (E, dist_feats)
-            Expanded distances, i.e. the output of RBFExpansion.
-
-        Returns
-        -------
-        node_feats : float32 tensor of shape (V, feats)
-            Updated node representations.
-        edge_feats : float32 tensor of shape (E, feats)
-            Updated edge representations.
-        """
-        new_node_feats = self.project_in_node_feats(node_feats)
-        new_node_feats, edge_feats = self.conv(
-            g, new_node_feats, edge_feats, expanded_dists
-        )
-        new_node_feats = self.project_out_node_feats(new_node_feats)
-        node_feats = node_feats + new_node_feats
-
-        edge_feats = self.project_edge_feats(edge_feats)
-
-        return node_feats, edge_feats
-
-
-class MGCNGNN(nn.Module):
-    """MGCN.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    This class performs message passing in MGCN and returns the updated node representations.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 30.
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 0.1.
-    """
-
-    def __init__(  # pylint: disable=to-many-arguments
-        self,
-        feats=128,
-        n_layers=3,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=30.0,
-        gap=0.1,
-    ):
-        super(MGCNGNN, self).__init__()
-
-        self.node_embed = nn.Embedding(num_node_types, feats)
-        self.edge_embed = EdgeEmbedding(num_edge_types, feats)
-        self.high = cutoff
-        self.gap = gap
-        self.rbf = RBFExpansion(high=cutoff, gap=gap)
-
-        self.gnn_layers = nn.ModuleList()
-        for _ in range(n_layers):
-            self.gnn_layers.append(MultiLevelInteraction(feats, len(self.rbf.centers)))
-
-    def reset_parameters(self):
-        """Reinitialize model parameters."""
-        self.node_embed.reset_parameters()
-        self.edge_embed.reset_parameters()
-        self.rbf.reset_parameters()
-
-        for layer in self.gnn_layers:
-            layer.reset_parameters()
-
-    def forward(self, g, node_types, edge_dists):
-        """Performs message passing and updates node representations.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (V, feats * (n_layers + 1))
-            Output node representations.
-        """
-
-        node_feats = self.node_embed(node_types)
-        edge_feats = self.edge_embed(g, node_types)
-        expanded_dists = self.rbf(edge_dists)
-
-        all_layer_node_feats = [node_feats]
-        for gnn in self.gnn_layers:
-            node_feats, edge_feats = gnn(g, node_feats, edge_feats, expanded_dists)
-            all_layer_node_feats.append(node_feats)
-        return torch.cat(all_layer_node_feats, dim=1)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py b/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
deleted file mode 100644
index 9f710fd3..00000000
--- a/qmctorch/wavefunction/jastrows/graph/mgcn/mgcn_predictor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# MGCN
-# pylint: disable= no-member, arguments-differ, invalid-name
-
-import torch.nn as nn
-from dgllife.model.readout import MLPNodeReadout
-from .mgcn import MGCNGNN
-
-
-class MGCNPredictor(nn.Module):
-    """MGCN for for regression and classification on graphs.
-
-    MGCN is introduced in `Molecular Property Prediction: A Multilevel Quantum Interactions
-    Modeling Perspective <https://arxiv.org/abs/1906.11081>`__.
-
-    Parameters
-    ----------
-    feats : int
-        Size for the node and edge embeddings to learn. Default to 128.
-    n_layers : int
-        Number of gnn layers to use. Default to 3.
-    classifier_hidden_feats : int
-        (Deprecated, see ``predictor_hidden_feats``) Size for hidden
-        representations in the classifier. Default to 64.
-    n_tasks : int
-        Number of tasks, which is also the output size. Default to 1.
-    num_node_types : int
-        Number of node types to embed. Default to 100.
-    num_edge_types : int
-        Number of edge types to embed. Default to 3000.
-    cutoff : float
-        Largest center in RBF expansion. Default to 5.0
-    gap : float
-        Difference between two adjacent centers in RBF expansion. Default to 1.0
-    predictor_hidden_feats : int
-        Size for hidden representations in the output MLP predictor. Default to 64.
-    """
-
-    def __init__(
-        self,
-        feats=128,
-        n_layers=3,
-        classifier_hidden_feats=64,
-        n_tasks=1,
-        num_node_types=100,
-        num_edge_types=3000,
-        cutoff=5.0,
-        gap=1.0,
-        predictor_hidden_feats=64,
-    ):
-        super(MGCNPredictor, self).__init__()
-
-        if predictor_hidden_feats == 64 and classifier_hidden_feats != 64:
-            print(
-                "classifier_hidden_feats is deprecated and will be removed in the future, "
-                "use predictor_hidden_feats instead"
-            )
-            predictor_hidden_feats = classifier_hidden_feats
-
-        self.gnn = MGCNGNN(
-            feats=feats,
-            n_layers=n_layers,
-            num_node_types=num_node_types,
-            num_edge_types=num_edge_types,
-            cutoff=cutoff,
-            gap=gap,
-        )
-        self.readout = MLPNodeReadout(
-            node_feats=(n_layers + 1) * feats,
-            hidden_feats=predictor_hidden_feats,
-            graph_feats=n_tasks,
-            activation=nn.Softplus(beta=1, threshold=20),
-        )
-
-    def forward(self, g, node_types, edge_dists):
-        """Graph-level regression/soft classification.
-
-        Parameters
-        ----------
-        g : DGLGraph
-            DGLGraph for a batch of graphs.
-        node_types : int64 tensor of shape (V)
-            Node types to embed, V for the number of nodes.
-        edge_dists : float32 tensor of shape (E, 1)
-            Distances between end nodes of edges, E for the number of edges.
-
-        Returns
-        -------
-        float32 tensor of shape (G, n_tasks)
-            Prediction for the graphs in the batch. G for the number of graphs.
-        """
-        node_feats = self.gnn(g, node_types, edge_dists)
-        return self.readout(g, node_feats)
diff --git a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
similarity index 97%
rename from qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
rename to qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
index a2c409c1..0dadc183 100644
--- a/qmctorch/wavefunction/jastrows/graph/jastrow_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -3,20 +3,18 @@
 from torch.autograd import grad
 import dgl
 
-from .mgcn.mgcn_predictor import MGCNPredictor
+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
 
 
-class JastrowFactorGraph(nn.Module):
+class MGCNJastrowFactor(nn.Module):
     def __init__(
         self,
         mol,
-        ee_model=MGCNPredictor,
         ee_model_kwargs={},
-        en_model=MGCNPredictor,
         en_model_kwargs={},
         atomic_features=["atomic_number"],
         cuda=False,
@@ -65,12 +63,12 @@ def __init__(
         # instantiate the ee mode; to use
         ee_model_kwargs["num_node_types"] = 2
         ee_model_kwargs["num_edge_types"] = 3
-        self.ee_model = ee_model(**ee_model_kwargs)
+        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 = en_model(**en_model_kwargs)
+        self.en_model = MGCNPredictor(**en_model_kwargs)
 
         # compute the elec-elec graph
         self.ee_graph = ElecElecGraph(self.nelec, self.nup)
diff --git a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
index 67ac08ab..ba007f12 100644
--- a/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
+++ b/tests/wavefunction/jastrows/graph/test_graph_jastrow.py
@@ -3,8 +3,7 @@
 import torch
 from torch.autograd import Variable, grad
 from types import SimpleNamespace
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import JastrowFactorGraph
-from qmctorch.wavefunction.jastrows.graph.mgcn.mgcn_predictor import MGCNPredictor
+from qmctorch.wavefunction.jastrows.graph.mgcn_jastrow import MGCNJastrowFactor
 
 torch.set_default_tensor_type(torch.DoubleTensor)
 
@@ -45,11 +44,9 @@ def setUp(self):
             atoms=self.atom_types,
         )
 
-        self.jastrow = JastrowFactorGraph(
+        self.jastrow = MGCNJastrowFactor(
             self.mol,
-            ee_model=MGCNPredictor,
             ee_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
-            en_model=MGCNPredictor,
             en_model_kwargs={"n_layers": 3, "feats": 32, "cutoff": 5.0, "gap": 1.0},
         )
 

From 1c9e1248ae9c4002673ef8c13fb3a183792ca14b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 11:01:32 +0100
Subject: [PATCH 239/286] example

---
 docs/example/graph/h2.py               | 38 ++++++++++++++++++++++++++
 docs/example/{ => graph}/jast_graph.py | 12 ++++----
 2 files changed, 45 insertions(+), 5 deletions(-)
 create mode 100644 docs/example/graph/h2.py
 rename docs/example/{ => graph}/jast_graph.py (71%)

diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
new file mode 100644
index 00000000..53a292d2
--- /dev/null
+++ b/docs/example/graph/h2.py
@@ -0,0 +1,38 @@
+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 = 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},
+        )
+
+
+# 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)
+
+
+# solver
+solver = Solver(wf=wf, sampler=sampler)
+
+# single point
+obs = solver.single_point()
\ No newline at end of file
diff --git a/docs/example/jast_graph.py b/docs/example/graph/jast_graph.py
similarity index 71%
rename from docs/example/jast_graph.py
rename to docs/example/graph/jast_graph.py
index f6f3e6f7..d294fd0a 100644
--- a/docs/example/jast_graph.py
+++ b/docs/example/graph/jast_graph.py
@@ -1,5 +1,5 @@
 
-from qmctorch.wavefunction.jastrows.graph.jastrow_graph import MGCNJastrowFactor
+from qmctorch.wavefunction.jastrows.graph.mgcn_jastrow import MGCNJastrowFactor
 import torch
 from torch.autograd import grad
 from types import SimpleNamespace
@@ -26,8 +26,10 @@
 
 
 pos = torch.rand(10, 12)
-pos.requires_grad = True
-jval = jast(pos)
+# pos.requires_grad = True
+# jval = jast(pos)
 
-gval = jast(pos, derivative=1)
-hval = jast(pos, derivative=2)
+# gval = jast(pos, derivative=1)
+# hval = jast(pos, derivative=2)
+
+jast, djast, d2jast = jast(pos, derivative=[0, 1, 2], sum_grad=False)

From aee8bcd56ccfbf0b12af564a5054c2a0b7b1d82e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 14:03:52 +0100
Subject: [PATCH 240/286] fix single point

---
 docs/example/graph/h2.py                      | 40 ++++++++++++++-----
 docs/example/optimization/h2.py               |  3 +-
 qmctorch/solver/solver_base.py                |  3 ++
 .../jastrows/graph/mgcn_jastrow.py            |  4 ++
 4 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
index 53a292d2..cb0b77bd 100644
--- a/docs/example/graph/h2.py
+++ b/docs/example/graph/h2.py
@@ -1,3 +1,5 @@
+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
@@ -14,25 +16,43 @@
 # jastrow
 jastrow = 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},
+            ee_model_kwargs={"n_layers": 2, "feats": 8, "classifier_hidden_feats": 4, "cutoff": 15.0, "gap": 1.0},
+            en_model_kwargs={"n_layers": 2, "feats": 8, "classifier_hidden_feats": 4, "cutoff": 15.0, "gap": 1.0},
         )
 
 
 # define the wave function
 wf = SlaterJastrow(mol, kinetic='jacobi',
-                   configs='ground_state', jastrow=jastrow) #.gto2sto()
+                   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)
+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-2},
+           {'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)
+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()
\ No newline at end of file
+# obs = solver.single_point()
+obs = solver.run(5)
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index ca6aedac..70f6fd28 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -40,7 +40,8 @@
 #                       ntherm=-1, ndecor=10,
 #                       init=mol.domain('atomic'))
 
-sampler = Metropolis(nwalkers=10, nstep=200, nelec=wf.nelec, ntherm=100, ndecor=10,
+sampler = Metropolis(nwalkers=10, nstep=200, nelec=wf.nelec, 
+                     ntherm=100, ndecor=10,
                      step_size=0.05, init=mol.domain('atomic'))
 
 # optimizer
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index e9123408..09f7890b 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -323,6 +323,9 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
         if self.wf.kinetic == "auto":
             grad_mode = torch.enable_grad()
 
+        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)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
index 0dadc183..33dadaa4 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -78,6 +78,10 @@ def __init__(
             self.natoms, self.atom_types, self.atomic_features, self.nelec, self.nup
         )
 
+    def __repr__(self):
+        """representation of the jastrow factor"""
+        return "ee, en graph -> " + self.__class__.__name__
+
     def forward(self, pos, derivative=0, sum_grad=True):
         """Compute the Jastrow factors.
 

From 45cf3ca8945f009be4bd4f4a7dc8fd9e8abf6351 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 15:58:39 +0100
Subject: [PATCH 241/286] refactor backflow test

---
 .../orbitals/backflow/test_backflow_base.py   | 297 ++++++++++++++++++
 .../test_backflow_kernel_exp_pyscf.py         |  36 +++
 .../test_backflow_kernel_generic_pyscf.py     | 158 +---------
 .../test_backflow_kernel_inverse_pyscf.py     | 160 +---------
 .../test_backflow_transformation_pyscf.py     |  83 +----
 .../test_backflow_transformation_rbf_pyscf.py |  86 +----
 ...dependent_backflow_transformation_pyscf.py | 108 +------
 7 files changed, 343 insertions(+), 585 deletions(-)
 create mode 100644 tests/wavefunction/orbitals/backflow/test_backflow_base.py
 create mode 100644 tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py

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 f9db68fe..b4fc52d6 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -8,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()
 
@@ -15,41 +16,6 @@
 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."""
@@ -74,7 +40,7 @@ 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"
@@ -91,126 +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 4e4e5cdc..1a19d8eb 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -8,48 +8,13 @@
 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"
@@ -66,126 +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 7d182fab..8457643c 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -9,48 +9,17 @@
 )
 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"
@@ -66,54 +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).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)
-
 
 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
index 7c8bb775..91983227 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -9,48 +9,15 @@
 )
 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)
 
 
-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"
@@ -66,54 +33,5 @@ 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).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)
-
-
 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 b22829c7..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
@@ -9,48 +9,14 @@
 )
 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"
@@ -72,76 +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([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)
-
 
 if __name__ == "__main__":
     unittest.main()

From 642cff61ca922e66b93b4c22e061300556279e44 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 15:59:16 +0100
Subject: [PATCH 242/286] backflow exp kernel

---
 docs/example/graph/h2.py                      | 12 ++-
 .../orbitals/backflow/kernels/__init__.py     |  2 +
 .../backflow/kernels/backflow_kernel_exp.py   | 73 +++++++++++++++++++
 3 files changed, 83 insertions(+), 4 deletions(-)
 create mode 100644 qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py

diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
index cb0b77bd..dd526405 100644
--- a/docs/example/graph/h2.py
+++ b/docs/example/graph/h2.py
@@ -14,10 +14,14 @@
                calculator='pyscf', basis='dzp', unit='bohr')
 
 # jastrow
-jastrow = MGCNJastrowFactor(
+jastrow = JastrowFactor(mol, PadeJastrowKernel)
+
+
+# jastrow
+_jastrow = MGCNJastrowFactor(
             mol,
-            ee_model_kwargs={"n_layers": 2, "feats": 8, "classifier_hidden_feats": 4, "cutoff": 15.0, "gap": 1.0},
-            en_model_kwargs={"n_layers": 2, "feats": 8, "classifier_hidden_feats": 4, "cutoff": 15.0, "gap": 1.0},
+            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},
         )
 
 
@@ -31,7 +35,7 @@
                      nelec=wf.nelec, ndim=wf.ndim, init=mol.domain('atomic'))
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
+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}]
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index f31d7b67..249d814d 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -5,6 +5,7 @@
 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",
@@ -14,4 +15,5 @@
     "BackFlowKernelPowerSum",
     "BackFlowKernelSquare",
     "BackFlowKernelRBF",
+    "BackFlowKernelExp"
 ]
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..45ca8070
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -0,0 +1,73 @@
+import torch
+from torch import nn
+
+from .....utils import register_extra_attributes
+from .backflow_kernel_base import BackFlowKernelBase
+
+
+class BackFlowKernelExp(BackFlowKernelBase):
+    def __init__(self, mol, cuda=False, weight=0.0, alpha=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([weight])) 
+
+    def _backflow_kernel(self, ree):
+        """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):
+        """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):
+        """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)

From 8a8be07151c8a1fde95c5e0a34723ec34ce80545 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Feb 2025 16:29:36 +0100
Subject: [PATCH 243/286] fix bf exp alpha value

---
 .../orbitals/backflow/kernels/backflow_kernel_exp.py            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index 45ca8070..e194f8af 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -20,7 +20,7 @@ def __init__(self, mol, cuda=False, weight=0.0, alpha=1.0):
         """
         super().__init__(mol, cuda)
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
-        self.alpha = nn.Parameter(torch.as_tensor([weight])) 
+        self.alpha = nn.Parameter(torch.as_tensor([alpha])) 
 
     def _backflow_kernel(self, ree):
         """Computes the backflow kernel:

From 1c5f15102b6a1107045d0da5380085d3e496915d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 10:28:04 +0100
Subject: [PATCH 244/286] clip in plot energy

---
 qmctorch/utils/plot_data.py | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/qmctorch/utils/plot_data.py b/qmctorch/utils/plot_data.py
index 5aab9334..85ae583f 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -10,7 +10,7 @@
 )
 
 
-def plot_energy(local_energy, e0=None, show_variance=False):
+def plot_energy(local_energy, e0=None, show_variance=False, clip=False, q=0.15):
     """Plot the evolution of the energy
 
     Args:
@@ -18,7 +18,16 @@ def plot_energy(local_energy, e0=None, show_variance=False):
         e0 (float, optional): Target value for the energy. Defaults to None.
         show_variance (bool, optional): show the variance if True. Defaults to False.
     """
-
+    def clip_values(values, std_factor=5):
+        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)
 
@@ -26,12 +35,15 @@ 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"
+        epoch, q25, q75, alpha=0.5, color="#4298f4"
     )
     ax.plot(epoch, energy, color="#144477")
     if e0 is not None:

From 7e0aec3105a9a1e9370f07b7c675a853f591b698 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 11:06:49 +0100
Subject: [PATCH 245/286] type hints added to ase and sampler

---
 qmctorch/ase/ase.py                           | 65 ++++++++------
 qmctorch/ase/optimizer/torch_optim.py         | 18 ++--
 qmctorch/sampler/generalized_metropolis.py    | 85 +++++++++++--------
 qmctorch/sampler/hamiltonian.py               | 70 ++++++++-------
 qmctorch/sampler/metropolis.py                |  6 +-
 qmctorch/sampler/metropolis_all_elec.py       | 11 +--
 .../sampler/metropolis_hasting_all_elec.py    | 31 +++----
 qmctorch/sampler/pints_sampler.py             | 42 ++++-----
 qmctorch/sampler/proposal_kernels.py          | 10 ++-
 qmctorch/sampler/sampler_base.py              | 42 +++++++--
 .../state_dependent_normal_proposal.py        | 50 +++++++++--
 qmctorch/sampler/walkers.py                   | 30 ++++---
 12 files changed, 288 insertions(+), 172 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 4dd9a0b6..5f7346bd 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -4,7 +4,7 @@
 import torch
 from torch import optim
 from types import SimpleNamespace
-
+from typing import bool
 from ..utils import set_torch_double_precision
 from ..utils.constants import ANGS2BOHR
 from ..scf.molecule import Molecule as SCF
@@ -20,12 +20,11 @@ class QMCTorch(Calculator):
     implemented_properties = ["energy", "forces"]
 
     def __init__(self,
-                 restart=None,
+                 restart: str = None,
                  *,
-                 labels=None,
-                 atoms=None,
-                 **kwargs):
-        
+                 labels: list = None,
+                 atoms: Atoms = None,
+                 **kwargs: dict) -> None:
         """
         Initialize a QMCTorchCalculator object.
 
@@ -39,10 +38,13 @@ def __init__(self,
             to set initial labels.
         atoms : Atoms object, optional
             The initial atomic configuration.
-        **kwargs
+        **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()
@@ -130,7 +132,7 @@ def validate_options(options: SimpleNamespace, recognized_options: list, name: s
                     "Invalid %s options: %s. Recognized options are %s" % (name, opt, recognized_options)
                 )
 
-    def run_scf(self):
+    def run_scf(self) -> None:
         """
         Set a default molecule called SCF here object. If the atoms object is not set, it raises
         a ValueError.
@@ -159,7 +161,7 @@ def run_scf(self):
                                  calculator=self.scf_options.calculator, 
                                  basis=self.scf_options.basis, redo_scf=True)
 
-    def set_wf(self):
+    def set_wf(self) -> None:
         """
         Set the default wave function for the QMCTorchCalculator.
 
@@ -208,7 +210,7 @@ def set_wf(self):
                 raise ValueError("gto2sto is only supported for pyscf")
             self.wf = self.wf.gto2sto()
 
-    def set_sampler(self):
+    def set_sampler(self) -> None:
         """
         Set default sampler object.
 
@@ -230,7 +232,7 @@ def set_sampler(self):
                                   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'), cuda=self.use_cuda)
         
-    def set_default_optimizer(self):
+    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},
@@ -240,7 +242,7 @@ def set_default_optimizer(self):
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
 
-    def set_resampling_options(self):
+    def set_resampling_options(self) -> None:
         """
         Configure the resampling options for the solver.
 
@@ -266,7 +268,7 @@ def set_resampling_options(self):
             if self.solver_options.resampling.ntherm_update != -1:
                 self.solver_options.resampling.ntherm_update = -1
 
-    def initialize(self):
+    def initialize(self) -> None:
         """
         Set the default solver object for the QMCTorchCalculator.
 
@@ -310,7 +312,7 @@ def initialize(self):
                 resampling=self.solver_options.resampling.__dict__
                 )
 
-    def set_atoms(self, atoms):
+    def set_atoms(self, atoms: Atoms) -> None:
         """
         Set atoms object.
 
@@ -322,7 +324,7 @@ def set_atoms(self, atoms):
         self.atoms = atoms
 
 
-    def reset(self):
+    def reset(self) -> None:
         """
         Reset the internal state of the QMCTorchCalculator.
 
@@ -340,7 +342,7 @@ def reset(self):
         self.has_forces = False
         self.reset_results()
 
-    def reset_results(self):
+    def reset_results(self) -> None:
         """
         Reset the results dictionary.
 
@@ -351,7 +353,7 @@ def reset_results(self):
         """
         self.results = {}
 
-    def reset_solver(self, atoms=None, force=True):
+    def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
         """
         Update the calculator.
 
@@ -364,14 +366,19 @@ def reset_solver(self, atoms=None, force=True):
         ----------
         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 any((self.atoms.get_positions() != np.array(self.molecule.atom_coords)).flatten().tolist()):
-            if not np.allclose(self.atoms.get_positions()*ANGS2BOHR, np.array(self.molecule.atom_coords)):
+            if not np.allclose(self.atoms.get_positions() * ANGS2BOHR, np.array(self.molecule.atom_coords)):
                 self.reset()
                 self.set_atoms(atoms)
                 self.initialize()
@@ -379,7 +386,8 @@ def reset_solver(self, atoms=None, force=True):
             if self.solver is None:
                 self.initialize()
 
-    def calculate(self, atoms=None, properties=['energy'], system_changes=None):
+    def calculate(self, atoms: Atoms = None, properties: 
+                  list = ['energy'], system_changes: any = None) -> float:
         """
         Calculate specified properties for the given atomic configuration.
 
@@ -396,6 +404,13 @@ def calculate(self, atoms=None, properties=['energy'], system_changes=None):
         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
         ------
@@ -423,7 +438,7 @@ def calculate(self, atoms=None, properties=['energy'], system_changes=None):
             elif p == 'energy':
                 return self._calculate_energy(atoms=atoms)
 
-    def _calculate_energy(self, atoms=None):
+    def _calculate_energy(self, atoms: Atoms =None) -> float:
         # check if reset is necessary 
         """
         Compute the energy using the wave function and the atomic positions.
@@ -459,7 +474,7 @@ def _calculate_energy(self, atoms=None):
         self.results['energy'] = observable.energy
         return self.results['energy']
 
-    def _calculate_forces(self, atoms=None):
+    def _calculate_forces(self, atoms: Atoms = None) -> float:
 
         # check if reset is necessary
         """
@@ -503,7 +518,7 @@ def _calculate_forces(self, atoms=None):
         self.has_forces = True
         return self.results['forces']
 
-    def check_forces(self):
+    def check_forces(self) -> bool:
         """
         Check if the forces have been computed.
 
@@ -517,7 +532,7 @@ def check_forces(self):
         self.has_forces = False
         return False
     
-    def get_forces(self, atoms=None):
+    def get_forces(self, atoms: Atoms = None) -> np.ndarray:
         """
         Return the total forces.
 
@@ -538,7 +553,7 @@ def get_forces(self, atoms=None):
         else:
             return self._calculate_forces(atoms=atoms)
     
-    def get_total_energy(self, atoms=None):
+    def get_total_energy(self, atoms: Atoms=None) -> float:
         """
         Return the total energy.
 
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index fd719fe3..55456cca 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -1,4 +1,5 @@
 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
@@ -34,7 +35,7 @@ def __init__(self,
         self.nepoch_wf_update = nepoch_wf_update
         self.xyz_trajectory = None
 
-    def log(self, e, forces):
+    def log(self, e: float, forces: np.ndarray) -> float:
         """
         Write to the log file.
 
@@ -42,13 +43,18 @@ def log(self, e, forces):
         ----------
         e : float
             Energy of the system.
-        forces : array
+        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.
+        energy, forces, and time to the log file.
         """
         fmax = sqrt((forces ** 2).sum(axis=1).max())
         T = time.localtime()
@@ -65,7 +71,7 @@ def log(self, e, forces):
             self.logfile.flush()
         return fmax
     
-    def run(self, fmax, steps=10, hdf5_group="geo_opt"):
+    def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> SimpleNamespace:
         """
         Run a geometry optimization.
 
@@ -80,7 +86,7 @@ def run(self, fmax, steps=10, hdf5_group="geo_opt"):
 
         Returns
         -------
-        observable
+        observable : Observable
             The observable instance containing the optimized geometry.
 
         Notes
@@ -150,4 +156,4 @@ def run(self, fmax, steps=10, hdf5_group="geo_opt"):
         solver.observable.geometry = self.xyz_trajectory
         solver.save_data(hdf5_group)
 
-        return solver.observable
\ No newline at end of file
+        return solver.observable
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index d83aabbc..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
@@ -11,45 +12,50 @@
 class GeneralizedMetropolis(SamplerBase):
     def __init__(  # pylint: disable=dangerous-default-value
         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,
-    ):
+        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
         )
 
-    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:
@@ -112,64 +118,73 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
 
         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.walkers.nwalkers, self.nelec, self.ndim)
 
-        # get indexes
+        # Get random indices for electrons to move
         index = torch.LongTensor(self.walkers.nwalkers).random_(0, self.nelec)
 
+        # Update positions of selected electrons
         new_pos[range(self.walkers.nwalkers), index, :] += self._move(drift, index)
 
+        # 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
         """
 
+        # Reshape drift to (nwalkers, nelec, ndim)
         d = drift.view(self.walkers.nwalkers, self.nelec, 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)
         )
 
+        # 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)
 
-    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:
@@ -186,16 +201,16 @@ def get_drift(self, pdf, x):
             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 afeef692..5804f5e2 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
@@ -42,15 +42,16 @@ def __init__(
         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:
@@ -64,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:
@@ -75,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:
@@ -101,7 +107,9 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
         idecor = 0
 
         rng = tqdm(
-            range(self.nstep), desc="INFO:QMCTorch|  Sampling", disable=not with_tqdm
+            range(self.nstep),
+            desc="INFO:QMCTorch|  Sampling",
+            disable=not with_tqdm,
         )
 
         for istep in rng:
@@ -128,54 +136,58 @@ def __call__(self, pdf, pos=None, with_tqdm=True):
         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
+        # 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
+        # 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
+        # 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
         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 be30cbdb..076285e1 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -21,7 +21,7 @@ def __init__(  # pylint: disable=dangerous-default-value
         move: Dict = {"type": "all-elec", "proba": "normal"},
         logspace: bool = False,
         cuda: bool = False,
-    ):
+    ) -> None:
         """Metropolis Hasting generator
 
         Args:
@@ -60,7 +60,7 @@ def __init__(  # pylint: disable=dangerous-default-value
         self.configure_move(move)
         self.log_data()
 
-    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"])
@@ -169,7 +169,7 @@ def __call__(
 
         return torch.cat(pos).requires_grad_()
 
-    def configure_move(self, move: Dict):
+    def configure_move(self, move: Dict) -> None:
         """Configure the electron moves
 
         Args:
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 9184ad7f..bcb00645 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -69,20 +69,21 @@ def __init__(
 
         self.log_data()
 
-    def log_data(self):
+    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):
-        """Compute the negative log of  a function
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
+        """Compute the log of a function
 
         Args:
-            func (callable): input function
+            func (Callable[[torch.Tensor], torch.Tensor]): input function
 
         Returns:
-            callable: negative log of the function
+            Callable[[torch.Tensor], torch.Tensor]: log of the function
         """
         return lambda x: torch.log(func(x))
 
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index b1473878..cc251d55 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -5,14 +5,14 @@
 from .sampler_base import SamplerBase
 from .. import log
 
-from .proposal_kernels import ConstantVarianceKernel
+from .proposal_kernels import ConstantVarianceKernel, BaseProposalKernel
 from .state_dependent_normal_proposal import StateDependentNormalProposal
 
 
 class MetropolisHasting(SamplerBase):
     def __init__(
         self,
-        kernel=ConstantVarianceKernel(0.2),
+        kernel: BaseProposalKernel = ConstantVarianceKernel(0.2),
         nwalkers: int = 100,
         nstep: int = 1000,
         ntherm: int = -1,
@@ -22,29 +22,23 @@ def __init__(
         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.
-            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.
+            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()
-
-            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
+            logspace (bool, optional):  Defaults to False.
             cuda (bool, optional): turn CUDA ON/OFF. Defaults to False.
 
+        Returns:
+            None
 
         Examples::
             >>> mol = Molecule('h2.xyz')
@@ -66,16 +60,17 @@ def __init__(
 
         self.log_data()
 
-    def log_data(self):
+    def log_data(self) -> None:
         """log data about the sampler."""
         # log.info('  Move type           : {0}', 'all-elec')
 
     @staticmethod
-    def log_func(func):
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of  a function
 
         Args:
-            func (callable): input function
+            func: input function
 
         Returns:
             callable: negative log of the function
@@ -84,7 +79,7 @@ def log_func(func):
 
     def __call__(
         self,
-        pdf: Callable,
+        pdf: Callable[[torch.Tensor], torch.Tensor],
         pos: Union[None, torch.Tensor] = None,
         with_tqdm: bool = True,
     ) -> torch.Tensor:
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index 3920406c..d1ebe480 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -1,40 +1,41 @@
 import torch
 import pints
-from typing import Callable, Union, Dict
+import numpy
+from typing import Callable, Union, Dict, Tuple
 from .sampler_base import SamplerBase
 
 
 class torch_model(pints.LogPDF):
-    def __init__(self, pdf, ndim):
-        """Ancillary class tha wrap the wave function in a PINTS class
+    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 (callable): wf.pdf function
-            ndim (int): number of dimensions
+            pdf: wf.pdf function
+            ndim: number of dimensions
         """
-        self.pdf = pdf
-        self.ndim = ndim
 
-    def __call__(self, x):
-        """Evalaute the log pdf of the wave function at points x
+    def __call__(self, x: numpy.ndarray) -> numpy.ndarray:
+        """Evaluate the log pdf of the wave function at points x
 
         Args:
-            x (numpy array): positions of the walkers
+            x: positions of the walkers (numpy array)
 
         Returns:
-            numpy.array: values of the log pdfat those points
+            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):
-        """Evalaute the log pdf and the gradients of the log pdf at points x
+    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.array): positions of the walkers
+            x (numpy.ndarray): positions of the walkers
 
         Returns:
-            tuple: values of the log pdf and gradients
+            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)
@@ -44,7 +45,7 @@ def evaluateS1(self, x):
         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):
+    def n_parameters(self) -> int:
         """Returns the number of dimensions."""
         return self.ndim
 
@@ -111,16 +112,15 @@ def log_data(self):
         #     '  Sampler             : {0}', self.method.name(None))
 
     @staticmethod
-    def log_func(func):
-        """Compute the negative log of  a function
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
+        """Compute the negative log of a function
 
         Args:
-            func (callable): input function
+            func (Callable[[torch.Tensor], torch.Tensor]): input function
 
         Returns:
-            callable: negative log of the function
+            Callable[[torch.Tensor], torch.Tensor]: negative log of the function
         """
-
         return lambda x: torch.log(func(torch.as_tensor(x)))
 
     def __call__(
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index 7471056d..508a9290 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -1,7 +1,11 @@
 import torch
 
 
-class DensityVarianceKernel(object):
+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
@@ -26,7 +30,7 @@ def get_estimate_density(self, pos):
         return d
 
 
-class CenterVarianceKernel(object):
+class CenterVarianceKernel(BaseProposalKernel):
     def __init__(self, sigma=1.0, scale_factor=1.0):
         self.sigma = sigma
         self.scale_factor = scale_factor
@@ -46,7 +50,7 @@ def get_estimate_density(self, pos):
         return d
 
 
-class ConstantVarianceKernel(object):
+class ConstantVarianceKernel(BaseProposalKernel):
     def __init__(self, sigma=0.2):
         self.sigma = sigma
 
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index f9dd33f6..9f037ed2 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -1,13 +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
-    ):
+        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:
@@ -15,11 +24,11 @@ def __init__(
             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
@@ -36,7 +45,11 @@ def __init__(
             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("")
@@ -48,16 +61,27 @@ def __init__(
         log.info("  Decorelation steps  : {0}", self.ndecor)
         log.info("  Walkers init pos    : {0}", init["method"])
 
-    def __call__(self, pdf, *args, **kwargs):
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor], *args, **kwargs) -> torch.Tensor:
+        """
+        Evaluate the sampling algorithm.
+
+        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):
+    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.walkers.nwalkers
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index 1968e3fa..89196d1e 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -1,9 +1,26 @@
 import torch
+from typing import Callable
 from torch.distributions import MultivariateNormal
 
 
 class StateDependentNormalProposal(object):
-    def __init__(self, kernel, nelec, ndim, device):
+    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
@@ -12,14 +29,35 @@ def __init__(self, kernel, nelec, ndim, device):
             torch.zeros(self.ndim), 1.0 * torch.eye(self.ndim)
         )
 
-    def __call__(self, x):
+    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)
-        displacement = self.multiVariate.sample((nwalkers, self.nelec)).to(self.device)
-        displacement *= scale
+        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, y):
+    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)
 
diff --git a/qmctorch/sampler/walkers.py b/qmctorch/sampler/walkers.py
index a85b111d..36656706 100644
--- a/qmctorch/sampler/walkers.py
+++ b/qmctorch/sampler/walkers.py
@@ -13,7 +13,7 @@ def __init__(  # pylint: disable=too-many-arguments
         ndim: int = 3,
         init: Union[Dict, None] = None,
         cuda: bool = False,
-    ):
+    ) -> None:
         """Creates Walkers for the sampler.
 
         Args:
@@ -38,7 +38,7 @@ def __init__(  # pylint: disable=too-many-arguments
         else:
             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:
@@ -73,46 +73,52 @@ def initialize(self, pos: Union[None, torch.Tensor] = None):
             else:
                 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):
+    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)
 
-    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"]),
         )
+        # 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

From 6a608b619593d237c9f29436555598d454130033 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 11:26:09 +0100
Subject: [PATCH 246/286] type hints added scf

---
 qmctorch/scf/calculator/adf.py   | 113 ++++++++++++++++++++-----
 qmctorch/scf/calculator/pyscf.py |  51 ++++++++++--
 qmctorch/scf/molecule.py         | 139 +++++++++++++++++--------------
 3 files changed, 213 insertions(+), 90 deletions(-)

diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 22006a91..5f94a4f3 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -2,7 +2,7 @@
 import shutil
 import warnings
 from types import SimpleNamespace
-
+from typing import BinaryIO, List
 import numpy as np
 
 from ... import log
@@ -17,8 +17,37 @@
 
 class CalculatorADF(CalculatorBase):
     def __init__(  # pylint: disable=too-many-arguments
-        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
-    ):
+        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.
+
+        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,
@@ -50,7 +79,7 @@ def __init__(  # pylint: disable=too-many-arguments
         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
@@ -85,18 +114,18 @@ def run(self):
 
         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 finish_plams(self):
+    def finish_plams(self) -> None:
         """Finish PLAMS."""
         plams.finish()
 
-    def get_plams_molecule(self):
+    def get_plams_molecule(self) -> plams.Molecule:
         """Returns a plams molecule object."""
         mol = plams.Molecule()
         bohr2angs = BOHR2ANGS # the coordinate are always in bohr
@@ -105,8 +134,13 @@ def get_plams_molecule(self):
             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"
@@ -148,9 +182,16 @@ def get_plams_settings(self):
 
         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"
@@ -250,16 +291,16 @@ 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 == ():
@@ -269,8 +310,34 @@ def read_array(kf, section, name):
 
 class CalculatorADF2019(CalculatorADF):
     def __init__(
-        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
+        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.
+
+        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, charge, spin, scf, units, molname, savefile
         )
@@ -279,15 +346,23 @@ def __init__(
         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()
diff --git a/qmctorch/scf/calculator/pyscf.py b/qmctorch/scf/calculator/pyscf.py
index 06d75fe9..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
@@ -9,8 +10,34 @@
 
 class CalculatorPySCF(CalculatorBase):
     def __init__(
-        self, atoms, atom_coords, basis, charge, spin, scf, units, molname, savefile
-    ):
+        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,
@@ -25,8 +52,13 @@ def __init__(
             savefile,
         )
 
-    def run(self):
-        """Run the scf calculation using PySCF."""
+    def run(self) -> SimpleNamespace:
+        """
+        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()
@@ -58,12 +90,15 @@ def run(self):
         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
@@ -205,7 +240,7 @@ def get_basis_data(self, mol, rhf):
 
         return basis
 
-    def get_atoms_str(self):
+    def get_atoms_str(self) -> str:
         """Refresh the atom string (use after atom move)."""
         atoms_str = ""
         natom = len(self.atoms)
@@ -217,7 +252,7 @@ def get_atoms_str(self):
         return atoms_str
 
     @staticmethod
-    def get_bas_n(mol):
+    def get_bas_n(mol: gto.M) -> List[str]:
         recognized_labels = ["s", "p", "d"]
 
         label2int = {"s": 1, "p": 2, "d": 3}
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 2f5842e8..c2429a0b 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -1,5 +1,6 @@
 import os
 import numpy as np
+from typing import Dict, List
 from mendeleev import element
 from types import SimpleNamespace
 import h5py
@@ -19,70 +20,73 @@
 class Molecule:
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        atom=None,
-        calculator="adf",
-        scf="hf",
-        basis="dzp",
-        unit="bohr",
-        charge=0,
-        spin=0,
-        name=None,
-        load=None,
-        save_scf_file=False,
-        redo_scf=False,
-        rank=0,
-        mpi_size=0,
-    ):
+        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 calculator
-            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
-            charge (int, optional): extra charge on the molecule, Default to 0
-            spin (int, optional): exess of spin up electrons on the molecule, Default 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 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
+            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.charge = charge
-        self.spin = spin
-        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("")
@@ -156,7 +160,7 @@ def __init__(  # pylint: disable=too-many-arguments
                     log.info("  Loading data from {file}", file=self.hdf5file)
                     self._load_hdf5(self.hdf5file)
 
-    def log_data(self):
+    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)
@@ -168,7 +172,7 @@ def log_data(self):
             "  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:
@@ -208,7 +212,7 @@ def domain(self, method):
 
         return domain
 
-    def _process_atom_str(self):
+    def _process_atom_str(self) -> None:
         """Process the atom description."""
 
         if self.atoms_str.endswith(".xyz"):
@@ -221,7 +225,7 @@ def _process_atom_str(self):
 
         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:
@@ -260,7 +264,7 @@ def _get_atomic_properties(self, atoms):
             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:
@@ -278,7 +282,16 @@ def _read_xyz_file(self):
         return atoms
 
     @staticmethod
-    def _get_mol_name(atoms):
+    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:
@@ -288,7 +301,7 @@ 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")
@@ -335,7 +348,7 @@ def _load_basis(self):
         h5.close()
         return self.basis
 
-    def print_total_energy(self):
+    def print_total_energy(self) -> None:
         """Print the SCF energy of the molecule.
 
         Examples::
@@ -345,14 +358,14 @@ def print_total_energy(self):
         e = self.get_total_energy()
         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.close()
         return e
 
-    def _check_basis(self):
+    def _check_basis(self) -> None:
         """Check if the basis contains all the necessary fields."""
 
         names = [
@@ -377,7 +390,7 @@ def _check_basis(self):
             if not hasattr(self.basis, n):
                 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:

From 5444555fa3a34e5a77aab43aec533327c591b81e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 11:58:00 +0100
Subject: [PATCH 247/286] added type hints to solver

---
 qmctorch/solver/solver.py      | 72 +++++++++++++++++++-----------
 qmctorch/solver/solver_base.py | 81 ++++++++++++++++++++--------------
 qmctorch/solver/solver_mpi.py  | 76 ++++++++++++++++++-------------
 3 files changed, 140 insertions(+), 89 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index be7f7bc4..87f90c3f 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -1,6 +1,10 @@
 from copy import deepcopy
 from time import time
 from tqdm import tqdm
+from types import SimpleNamespace
+from typing import Optional, Dict, Union, List, bool, Tuple, Any
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
 import torch
 from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 
@@ -10,8 +14,14 @@
 
 class Solver(SolverBase):
     def __init__(  # pylint: disable=too-many-arguments
-        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
-    ):
+        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:
@@ -36,22 +46,22 @@ def __init__(  # pylint: disable=too-many-arguments
             resampling={"mode": "update", "resample_every": 1, "nstep_update": 25},
         )
 
-    def configure(  # pylint: disable=too-many-arguments
+    def configure(
         self,
-        track=None,
-        freeze=None,
-        loss=None,
-        grad=None,
-        ortho_mo=None,
-        clip_loss=False,
-        resampling=None,
-    ):
+        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,
+        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'.
@@ -60,6 +70,7 @@ def configure(  # pylint: disable=too-many-arguments
             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
@@ -94,7 +105,9 @@ def configure(  # pylint: disable=too-many-arguments
             log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
             self.ortho_loss = OrthoReg()
 
-    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
@@ -114,7 +127,7 @@ def set_params_requires_grad(self, wf_params=True, geo_params=False):
         # 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:
@@ -148,7 +161,7 @@ def freeze_parameters(self, freeze):
                     opt_freeze = ["ci", "mo", "ao", "jastrow", "backflow"]
                     raise ValueError("Valid arguments for freeze are :", opt_freeze)
 
-    def save_sampling_parameters(self):
+    def save_sampling_parameters(self) -> None:
         """save the sampling params."""
         self.sampler._nstep_save = self.sampler.nstep
         self.sampler._ntherm_save = self.sampler.ntherm
@@ -159,7 +172,7 @@ def save_sampling_parameters(self):
             self.sampler.nstep = self.resampling_options.nstep_update
             # 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
@@ -167,8 +180,13 @@ def restore_sampling_parameters(self):
 
 
     def run(
-        self, nepoch, batchsize=None, hdf5_group="wf_opt", chkpt_every=None, tqdm=False
-    ):
+        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:
@@ -196,7 +214,7 @@ def run(
 
         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:
@@ -227,7 +245,7 @@ def prepare_optimization(self, batchsize, chkpt_every, tqdm=False):
 
         log.info("  done in %1.2f sec." % (time() - tstart))
 
-    def save_data(self, hdf5_group):
+    def save_data(self, hdf5_group: str):
         """Save the data to hdf5.
 
         Args:
@@ -239,7 +257,9 @@ def save_data(self, hdf5_group):
 
         add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
-    def run_epochs(self, nepoch, with_tqdm=False, verbose=True):
+    def run_epochs(self, nepoch: int, 
+                   with_tqdm: Optional[bool] = False, 
+                   verbose: Optional[bool] = True) -> float :
         """Run a certain number of epochs
 
         Args:
@@ -320,7 +340,7 @@ def run_epochs(self, nepoch, with_tqdm=False, verbose=True):
 
         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:
@@ -342,7 +362,7 @@ def evaluate_grad_auto(self, lpos):
 
         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 
@@ -392,7 +412,7 @@ def evaluate_grad_manual(self, lpos):
         else:
             raise ValueError("Manual gradient only for energy minimization")
         
-    def evaluate_grad_manual_2(self, lpos):
+    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 
@@ -439,7 +459,7 @@ def evaluate_grad_manual_2(self, lpos):
         else:
             raise ValueError("Manual gradient only for energy minimization")
 
-    def log_data_opt(self, nepoch, task):
+    def log_data_opt(self, nepoch: int, task: str) -> None:
         """Log data for the optimization."""
         log.info("")
         log.info("  Optimization")
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 09f7890b..3e9e181e 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, bool, Tuple, Any
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
 import os
 import numpy as np
 import torch
@@ -10,15 +13,21 @@
 
 class SolverBase:
     def __init__(  # pylint: disable=too-many-arguments
-        self, wf=None, sampler=None, optimizer=None, scheduler=None, output=None, rank=0
-    ):
+        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.
         """
@@ -28,8 +37,8 @@ def __init__(  # pylint: disable=too-many-arguments
         self.opt = optimizer
         self.scheduler = scheduler
         self.cuda = False
-        self.device = torch.device("cpu")
-        self.qmctorch_version = get_git_tag()
+        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
@@ -41,7 +50,7 @@ def __init__(  # pylint: disable=too-many-arguments
             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:
@@ -51,9 +60,9 @@ def __init__(  # pylint: disable=too-many-arguments
         else:
             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]
+            basename: str = os.path.basename(self.wf.mol.hdf5file).split(".")[0]
             self.hdf5file = basename + "_QMCTorch.hdf5"
 
 
@@ -66,22 +75,22 @@ def __init__(  # pylint: disable=too-many-arguments
 
     def configure_resampling(  # pylint: disable=too-many-arguments
         self,
-        mode="update",
-        resample_every=1,
-        nstep_update=25,
-        ntherm_update=-1,
-        increment={"every": None, "factor": None},
+        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, optional): Number of MC steps to thermalize the new sampling.
+            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
@@ -100,7 +109,7 @@ def configure_resampling(  # pylint: disable=too-many-arguments
         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:
@@ -163,11 +172,13 @@ def track_observable(self, obs_name):
 
         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
@@ -233,7 +244,7 @@ def store_observable(self, pos, local_energy=None, ibatch=None, **kwargs):
                         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:
@@ -256,7 +267,7 @@ def print_observable(self, cumulative_loss, verbose=False):
                 )
                 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:
@@ -299,8 +310,10 @@ def resample(self, n, pos):
 
         return pos
 
-    def single_point(self, with_tqdm=True, batchsize=None, 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.
@@ -367,13 +380,12 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="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(
@@ -386,7 +398,7 @@ def save_checkpoint(self, epoch, loss):
             filename,
         )
 
-    def load_checkpoint(self, filename):
+    def load_checkpoint(self, filename: str) -> Tuple(int, float):
         """load a model/optmizer
 
         Args:
@@ -402,7 +414,7 @@ def load_checkpoint(self, filename):
         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:
@@ -414,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:
@@ -444,7 +459,7 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group="sampling_trajector
         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:
@@ -457,7 +472,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:
@@ -469,7 +484,7 @@ 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:
@@ -490,10 +505,10 @@ def save_traj(self, fname, obs):
             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("")
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 54e6a118..40217d5b 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -1,5 +1,8 @@
 from time import time
 from types import SimpleNamespace
+from typing import Optional, Dict, Union, List, bool, Tuple, Any
+from ..wavefunction import WaveFunction
+from ..sampler import SamplerBase
 
 import torch
 from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
@@ -13,15 +16,21 @@
     pass
 
 
-def logd(rank, *args):
+def logd(rank: int, *args):
     if rank == 0:
         log.info(*args)
 
 
 class SolverMPI(Solver):
-    def __init__(  # pylint: disable=too-many-arguments
-        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:
@@ -44,15 +53,15 @@ def __init__(  # pylint: disable=too-many-arguments
 
     def run(  # pylint: disable=too-many-arguments
         self,
-        nepoch,
-        batchsize=None,
-        loss="energy",
-        clip_loss=False,
-        grad="manual",
-        hdf5_group="wf_opt",
-        num_threads=1,
-        chkpt_every=None,
-    ):
+        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:
@@ -198,11 +207,18 @@ def run(  # pylint: disable=too-many-arguments
 
         return self.observable
 
-    def single_point(self, with_tqdm=True, batchsize=None, 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'.
 
@@ -233,21 +249,21 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
 
         with grad_mode:
             # sample the wave function
-            pos = self.sampler(self.wf.pdf, with_tqdm=with_tqdm)
+            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:
@@ -257,7 +273,7 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="single_point"
                 log.options(style="percent").info("  Variance : %f" % s.detach().item())
 
             # dump data to hdf5
-            obs = SimpleNamespace(
+            obs: SimpleNamespace = SimpleNamespace(
                 pos=pos, local_energy=eloc_all, energy=e, variance=s, error=err
             )
 
@@ -269,15 +285,15 @@ def single_point(self, with_tqdm=True, batchsize=None, hdf5_group="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)

From 4d535418f7916109cdb0da2c28955d82ffc14d05 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 12:26:35 +0100
Subject: [PATCH 248/286] added type hints to uils

---
 qmctorch/utils/algebra_utils.py |  27 +++--
 qmctorch/utils/interpolate.py   | 171 ++++++++++++++++++++++----------
 qmctorch/utils/plot_data.py     | 117 ++++++++++++++--------
 qmctorch/utils/provenance.py    |   2 +-
 qmctorch/utils/stat_utils.py    |  38 +++++--
 qmctorch/utils/torch_utils.py   | 169 +++++++++++++++++++++----------
 6 files changed, 352 insertions(+), 172 deletions(-)

diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index 993c8de7..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:
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index c0b0c2ab..4b24139d 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -1,20 +1,35 @@
 from time import time
-
+from typing import Union, Tuple, List, Callable
 import numpy as np
 import torch
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
-
+from ..wavefunction import WaveFunction
 #################################################################################
 # TO DO : Remove this features as they are never used anywhere
 #################################################################################
 
 
 class InterpolateMolecularOrbitals:
-    def __init__(self, wf):
+    def __init__(self, wf: WaveFunction):
         """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.
+
+        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.
+
+        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)
@@ -25,7 +40,7 @@ def __call__(self, pos, method="irreg", orb="occupied", **kwargs):
             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:
@@ -33,6 +48,9 @@ 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":
@@ -42,41 +60,45 @@ def get_mo_max_index(self, orb):
         else:
             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"):
             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()
+                return mo[:, :self.mo_max_index].detach()
 
             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[:, :, :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
@@ -104,25 +126,25 @@ def func(x):
 
 
 class InterpolateAtomicOrbitals:
-    def __init__(self, wf):
+    def __init__(self, wf: WaveFunction):
         """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"):
             t0 = time()
-            self.get_interpolator()
+            self.get_interpolator(n=n, length=length)
             print("___", time() - t0)
 
         t0 = time()
@@ -147,14 +169,18 @@ def __call__(self, pos, n=6, length=2):
 
         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)
 
@@ -162,7 +188,7 @@ def get_interpolator(self, n=6, length=2):
             :, [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)
@@ -193,18 +219,21 @@ def func(x):
         ]
 
 
-def get_boundaries(atomic_positions, border_length=2.0):
+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()
@@ -228,16 +257,20 @@ def get_boundaries(atomic_positions, border_length=2.0):
     return pmin, pmax
 
 
-def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.0):
+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)
@@ -250,17 +283,22 @@ def get_reg_grid(atomic_positions, resolution=0.1, border_length=2.0):
     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]]
@@ -272,8 +310,11 @@ def interpolator_reg_grid(func, x, y, z):
     )
 
 
-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
@@ -291,13 +332,28 @@ def interpolate_reg_grid(interpfunc, pos):
     return torch.as_tensor(data)
 
 
-def is_even(x):
-    """return true if x is even."""
+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, length):
-    """returns a 1d array of logspace between -length and +length."""
+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
+
+    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
@@ -306,7 +362,12 @@ def logspace(n, length):
     return np.concatenate((-x[::-1], x[1:]))
 
 
-def get_log_grid(atomic_positions, n=6, length=2.0, border_length=2.0):
+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:
@@ -316,7 +377,7 @@ def get_log_grid(atomic_positions, n=6, length=2.0, border_length=2.0):
         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
@@ -334,22 +395,24 @@ def get_log_grid(atomic_positions, n=6, length=2.0, border_length=2.0):
     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.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
@@ -360,4 +423,4 @@ def interpolate_irreg_grid(interpfunc, pos):
     """
 
     nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
-    return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim)))
+    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 85ae583f..15222765 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -1,7 +1,8 @@
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
-
+from types import SimpleNamespace
+from typing import Optional, Union, Tuple
 from .stat_utils import (
     blocking,
     correlation_coefficient,
@@ -10,24 +11,32 @@
 )
 
 
-def plot_energy(local_energy, e0=None, show_variance=False, clip=False, q=0.15):
-    """Plot the evolution of the energy
+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, std_factor=5):
+    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
+            down = values > mean - std_factor * std
             return values[up * down]
         return values
-    
+
     fig = plt.figure()
     ax = fig.add_subplot(111)
 
@@ -35,11 +44,11 @@ def clip_values(values, std_factor=5):
     epoch = np.arange(n)
 
     # get the variance
-    
+
     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])
+    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(
@@ -63,11 +72,14 @@ def clip_values(values, std_factor=5):
     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
     """
 
@@ -81,12 +93,15 @@ def plot_data(observable, obsname):
     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
@@ -117,18 +132,27 @@ def plot_walkers_traj(eloc, walkers="mean"):
     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])
 
@@ -148,16 +172,23 @@ def plot_correlation_coefficient(eloc, size_max=100):
     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)
 
@@ -192,7 +223,7 @@ def plot_integrated_autocorrelation_time(eloc, rho=None, size_max=100, C=5):
     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:
@@ -200,6 +231,9 @@ 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]
     """
@@ -227,11 +261,11 @@ def plot_blocking_energy(eloc, block_size, walkers="mean"):
     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, _ = eloc.shape
@@ -250,11 +284,14 @@ def plot_correlation_time(eloc):
     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, _ = eloc.shape
diff --git a/qmctorch/utils/provenance.py b/qmctorch/utils/provenance.py
index 02caf492..9bc8d7ac 100644
--- a/qmctorch/utils/provenance.py
+++ b/qmctorch/utils/provenance.py
@@ -3,7 +3,7 @@
 from ..__version__ import __version__
 
 
-def get_git_tag():
+def get_git_tag() -> str:
     """
     Retrieves the current Git tag for the repository.
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index 81ec69cf..d06b2daa 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -3,12 +3,20 @@
 from scipy.signal import fftconvolve
 
 
-def blocking(x, block_size, expand=False):
+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
@@ -22,12 +30,16 @@ def blocking(x, block_size, expand=False):
     return xb
 
 
-def correlation_coefficient(x, norm=True):
+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 [MC steps, N walkers]
-        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]
@@ -41,17 +53,22 @@ 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
+
+    Returns:
+        np.ndarray: The computed integrated autocorrelation time
     """
     return 1.0 + 2.0 * np.cumsum(correlation_coeff[1:size_max], 0)
 
 
-def fit_correlation_coefficient(coeff):
+def fit_correlation_coefficient(coeff: np.ndarray) -> Tuple[float, np.ndarray]:
     """Fit the correlation coefficient
        to get the correlation time.
 
@@ -59,13 +76,14 @@ def fit_correlation_coefficient(coeff):
         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):
+        def func(x: np.ndarray, tau: float) -> np.ndarray:
             return np.exp(-x / tau)
 
         popt, _ = curve_fit(func, x, y, p0=(1.0))
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index e392f343..b44f8aac 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,11 +1,14 @@
+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
 
+from ..wavefunction import Wavefunction
 
-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
@@ -13,7 +16,7 @@ def set_torch_double_precision():
     # 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
@@ -21,17 +24,23 @@ def set_torch_single_precision():
     # 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:
@@ -53,25 +62,38 @@ 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))
@@ -99,15 +121,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:
@@ -115,7 +136,7 @@ def __len__(self):
         """
         return self.data.shape[0]
 
-    def __getitem__(self, index):
+    def __getitem__(self, index) -> torch.Tensor:
         """returns a given data point
 
         Arguments:
@@ -128,11 +149,13 @@ def __getitem__(self, index):
 
 
 class DataLoader:
-    def __init__(self, data, batch_size, pin_memory=False):
-        """Simple DataLoader to replace toch data loader
+    def __init__(
+        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]
+            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.
         """
@@ -148,10 +171,23 @@ def __init__(self, data, batch_size, pin_memory=False):
         self.batch_size = batch_size
 
     def __iter__(self):
+        """Initialize the iterator.
+
+        Returns:
+            DataLoader: The iterator instance.
+        """
         self.count = 0
         return self
 
-    def __next__(self):
+    def __next__(self) -> torch.Tensor:
+        """Returns the next batch of data points.
+
+        Returns:
+            torch.Tensor: The next batch of data points.
+
+        Raises:
+            StopIteration: If there are no more batches to return.
+        """
         if self.count < self.nbatch - 1:
             out = self.dataset[
                 self.count * self.batch_size : (self.count + 1) * self.batch_size
@@ -167,11 +203,14 @@ def __next__(self):
 
 
 class Loss(nn.Module):
-    def __init__(self, wf, method="energy", clip=False):
+    def __init__(self, 
+                 wf: Wavefunction, 
+                 method: str = "energy", 
+                 clip: bool = False):
         """Defines the loss to use during the optimization
 
         Arguments:
-            wf {WaveFunction} -- wave function object used
+            wf {Wavefunction} -- wave function object used
 
         Keyword Arguments:
             method {str} -- method to use  (default: {'energy'})
@@ -202,18 +241,23 @@ def __init__(self, wf, method="energy", clip=False):
         # init values of the weights
         self.weight = {"psi": None, "psi0": None}
 
-    def forward(self, pos, no_grad=False, deactivate_weight=False):
+    def forward(
+        self, 
+        pos: torch.Tensor, 
+        no_grad: bool = False,
+        deactivate_weight: bool = False
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the loss
 
-        Arguments:
-            pos {torch.tensor} -- positions of the walkers in that batch
-
-        Keyword Arguments:
-            no_grad {bool} -- computes the gradient of the loss
-                              (default: {False})
+        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:
-            torch.tensor, torch.tensor -- value of the loss, local energies
+            Tuple[torch.Tensor, torch.Tensor]: Value of the loss, local energies
         """
 
         # check if grads are requested
@@ -233,20 +277,25 @@ def forward(self, pos, no_grad=False, deactivate_weight=False):
         return loss, local_energies
 
     @staticmethod
-    def get_grad_mode(no_grad):
-        """Returns enable_grad or no_grad
+    def get_grad_mode(no_grad: bool) -> ContextManager:
+        """Returns a context manager to enable or disable gradient computation.
 
-        Arguments:
-            no_grad {bool} -- [description]
-        """
+        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):
-        """computes the clipping mask
+    def get_clipping_mask(self, local_energies: torch.Tensor) -> torch.Tensor:
+        """Computes the clipping mask.
 
-        Arguments:
-            local_energies {torch.tensor} -- values of the local energies
+        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)
@@ -259,9 +308,18 @@ def get_clipping_mask(self, local_energies):
 
         return mask
 
-    def get_sampling_weights(self, pos, deactivate_weight):
+    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)
@@ -283,21 +341,28 @@ def get_sampling_weights(self, pos, deactivate_weight):
             return w
 
         else:
-            return 1.0
+            return torch.tensor(1.0)
 
 
 class OrthoReg(nn.Module):
     """add a penalty to make matrice orthgonal."""
 
-    def __init__(self, alpha=0.1):
+    def __init__(self, alpha: float = 0.1) -> None:
         """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
+        self.alpha: float = alpha
+
+    def forward(self, W: torch.Tensor) -> torch.Tensor:
+        """Return the loss : |W x W^T - I|.
 
-    def forward(self, W):
-        """Return the loss : |W x W^T - I|."""
+        Args:
+            W: The matrix to orthogonalize
+
+        Returns:
+            The loss value
+        """
         return self.alpha * torch.norm(W.mm(W.transpose(0, 1)) - torch.eye(W.shape[0]))

From 69333be750c73c2194eee58010864f3911bfa97e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 14:26:06 +0100
Subject: [PATCH 249/286] hints on wavefunction

---
 qmctorch/ase/ase.py                     |  1 -
 qmctorch/sampler/hamiltonian.py         |  2 +-
 qmctorch/utils/interpolate.py           |  6 +-
 qmctorch/utils/stat_utils.py            |  2 +-
 qmctorch/wavefunction/slater_jastrow.py | 93 ++++++++++++++++---------
 qmctorch/wavefunction/wf_base.py        | 51 +++++++++-----
 6 files changed, 99 insertions(+), 56 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 5f7346bd..cf7f72eb 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -4,7 +4,6 @@
 import torch
 from torch import optim
 from types import SimpleNamespace
-from typing import bool
 from ..utils import set_torch_double_precision
 from ..utils.constants import ANGS2BOHR
 from ..scf.molecule import Molecule as SCF
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 5804f5e2..96b9a146 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -140,7 +140,7 @@ 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):
+              q_init: torch.Tensor) -> Tuple[torch.Tensor, float]:
         """Take one step of the sampler
 
         Args:
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index 4b24139d..a675e80b 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -3,14 +3,14 @@
 import numpy as np
 import torch
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
-from ..wavefunction import WaveFunction
+
 #################################################################################
 # TO DO : Remove this features as they are never used anywhere
 #################################################################################
 
 
 class InterpolateMolecularOrbitals:
-    def __init__(self, wf: WaveFunction):
+    def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
@@ -126,7 +126,7 @@ def func(x):
 
 
 class InterpolateAtomicOrbitals:
-    def __init__(self, wf: WaveFunction):
+    def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index d06b2daa..e734159d 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -1,7 +1,7 @@
 import numpy as np
 from scipy.optimize import curve_fit
 from scipy.signal import fftconvolve
-
+from typing import Tuple
 
 def blocking(
     x: np.ndarray,
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 7d925597..232d4aa6 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,4 +1,6 @@
 import torch
+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
@@ -11,7 +13,9 @@
 
 from .. import log
 
+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
@@ -26,15 +30,15 @@
 class SlaterJastrow(WaveFunction):
     def __init__(
         self,
-        mol,
-        jastrow='default',
-        backflow=None,
-        configs="ground_state",
-        kinetic="jacobi",
-        cuda=False,
-        include_all_mo=True,
-        orthogonalize_mo=False
-    ):
+        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,
+        orthogonalize_mo: bool = False
+    ) -> None:
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
         .. math::
@@ -49,8 +53,8 @@ def __init__(
 
         Args:
             mol (Molecule): a QMCTorch molecule object
-            jastrow (JastrowKernelBase, optional) : Class that computes the jastrow kernels
-            backflow (BackFlowKernelBase, optional) : kernel function of the backflow transformation
+            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
@@ -114,7 +118,7 @@ def __init__(
 
         self.log_data()
 
-    def init_atomic_orb(self, backflow):
+    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None])-> None:
         """Initialize the atomic orbital layer."""
         # self.backflow = backflow
         if backflow is None:
@@ -128,7 +132,7 @@ def init_atomic_orb(self, backflow):
         if self.cuda:
             self.ao = self.ao.to(self.device)
 
-    def init_molecular_orb(self, include_all_mo):
+    def init_molecular_orb(self, include_all_mo: bool)-> None:
         """initialize the molecular orbital layers"""
 
         # determine which orbs to include in the transformation
@@ -144,7 +148,7 @@ def init_molecular_orb(self, include_all_mo):
         if self.cuda:
             self.mo_scf.to(self.device)
 
-    def init_mo_mixer(self, orthogonalize_mo):
+    def init_mo_mixer(self, orthogonalize_mo: bool)-> None:
         """
         Initialize the molecular orbital mixing layer.
 
@@ -170,7 +174,7 @@ def init_mo_mixer(self, orthogonalize_mo):
         if self.cuda:
             self.mo.to(self.device)
 
-    def init_config(self, configs):
+    def init_config(self, configs: str)-> None:
         """Initialize the electronic configurations desired in the wave function."""
 
         # define the SD we want
@@ -180,7 +184,7 @@ def init_config(self, 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):
+    def init_slater_det_calculator(self)-> None:
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
@@ -188,7 +192,7 @@ def init_slater_det_calculator(self):
             self.configs_method, self.configs, self.mol, self.cuda
         )
 
-    def init_fc_layer(self):
+    def init_fc_layer(self)-> None:
         """Init the fc layer"""
 
         # init the layer
@@ -202,7 +206,7 @@ def init_fc_layer(self):
         if self.cuda:
             self.fc = self.fc.to(self.device)
 
-    def init_jastrow(self, jastrow):
+    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
@@ -233,11 +237,11 @@ def init_jastrow(self, jastrow):
             if self.cuda:
                 self.jastrow = self.jastrow.to(self.device)
 
-    def set_combined_jastrow(self, jastrow):
+    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, backflow):
+    def init_kinetic(self, kinetic: str, backflow: Union[BackFlowTransformation,None]) -> None:
         """ "Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
@@ -250,7 +254,10 @@ def init_kinetic(self, kinetic, backflow):
                 self.kinetic_energy_jacobi = self.kinetic_energy_jacobi_backflow
                 self.kinetic_energy = self.kinetic_energy_jacobi_backflow
 
-    def forward(self, x, ao=None):
+    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::
@@ -296,12 +303,16 @@ def forward(self, x, ao=None):
         # if we do not have a Jastrow
         return self.fc(x)
 
-    def ao2mo(self, ao):
+    def ao2mo(self, ao:torch.Tensor) -> torch.Tensor:
         """transforms AO values in to MO values."""
 
         return self.mo(self.mo_scf(ao))
 
-    def pos2mo(self, x, derivative=0, sum_grad=True):
+    def pos2mo(self, 
+               x: torch.Tensor, 
+               derivative: Optional[int] = 0, 
+               sum_grad: Optional[bool] = True
+               ) -> torch.Tensor:
         """Compute the MO vals from the pos
 
         Args:
@@ -316,7 +327,7 @@ def pos2mo(self, x, derivative=0, sum_grad=True):
         ao = self.ao(x, derivative=derivative, sum_grad=sum_grad)
         return self.ao2mo(ao)
 
-    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 .
 
@@ -350,7 +361,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.
 
@@ -448,7 +463,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:
@@ -476,7 +497,7 @@ def get_kinetic_operator(self, x, ao, dao, d2ao, mo):
 
         return -0.5 * bkin
 
-    def kinetic_energy_jacobi_backflow(self, x, **kwargs):
+    def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         """Compute the value of the kinetic enery using the Jacobi Formula.
 
 
@@ -583,7 +604,10 @@ def kinetic_energy_jacobi_backflow(self, x, **kwargs):
         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, sum_grad=True, pdf=False):
+    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:
@@ -593,7 +617,7 @@ def gradients_jacobi_backflow(self, x, sum_grad=True, pdf=False):
             "Gradient through Jacobi formula not implemented for backflow orbitals"
         )
 
-    def log_data(self):
+    def log_data(self) -> None:
         """Print information abut the wave function."""
         log.info("")
         log.info(" Wave Function")
@@ -619,19 +643,20 @@ def log_data(self):
         if self.cuda:
             log.info("  GPU                 : {0}", torch.cuda.get_device_name(0))
 
-    def get_mo_coeffs(self):
+    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 nn.Parameter(mo_coeff.transpose(0, 1).contiguous())
 
-    def update_mo_coeffs(self):
+    def update_mo_coeffs(self) -> None:
         """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, convert_to_angs=False):
+    def geometry(self, pos: torch.Tensor, 
+                 convert_to_angs: Optional[bool] = False) -> List:
         """Returns the gemoetry of the system in xyz format
 
         Args:
@@ -649,7 +674,7 @@ def geometry(self, pos, convert_to_angs=False):
             d.append(xyz.tolist())
         return d
     
-    def forces(self):
+    def forces(self) -> torch.Tensor:
         """
         Returns the gradient of the atomic coordinates with respect to the wave function.
 
@@ -660,7 +685,7 @@ def forces(self):
         """
         return self.ao.atom_coords.grad
 
-    def gto2sto(self, plot=False):
+    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
         """
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index 3f6c7c12..45dfa42f 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -1,10 +1,23 @@
 import h5py
 import torch
+from typing import Optional, bool
 from torch.autograd import Variable, grad
 
 
 class WaveFunction(torch.nn.Module):
-    def __init__(self, nelec, ndim, kinetic="auto", cuda=False):
+    def __init__(self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False):
+        """
+        Base class for wave functions.
+
+        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
@@ -18,7 +31,7 @@ def __init__(self, nelec, ndim, kinetic="auto", cuda=False):
         self.kinetic_energy = self.kinetic_energy_autograd
         self.gradients = self.gradients_autograd
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor):
         """Compute the value of the wave function.
         for a multiple conformation of the electrons
 
@@ -31,7 +44,7 @@ def forward(self, x):
 
         raise NotImplementedError()
 
-    def electronic_potential(self, pos):
+    def electronic_potential(self, pos: torch.Tensor) -> torch.Tensor:
         r"""Computes the electron-electron term
 
         .. math:
@@ -54,7 +67,7 @@ def electronic_potential(self, pos):
                 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,7 +92,7 @@ def nuclear_potential(self, pos):
                 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:
@@ -100,7 +113,10 @@ def nuclear_repulsion(self):
                 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.
 
@@ -122,7 +138,7 @@ def gradients_autograd(self, pos, pdf=False):
 
         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.
 
@@ -152,7 +168,7 @@ def kinetic_energy_autograd(self, pos):
 
         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::
@@ -185,37 +201,37 @@ def local_energy(self, pos):
             + self.nuclear_repulsion()
         )
 
-    def energy(self, pos):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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)
         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 _, param in self.named_parameters():
@@ -223,7 +239,10 @@ def get_number_parameters(self):
                 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:

From 505d2090edaabf05cb236b95f48c419c0e3cac82 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 16:02:27 +0100
Subject: [PATCH 250/286] hints on ao

---
 .../wavefunction/orbitals/atomic_orbitals.py  | 115 ++++++++-----
 .../orbitals/atomic_orbitals_backflow.py      |  45 ++++--
 .../backflow/backflow_transformation.py       |  38 +++--
 .../backflow_kernel_autodiff_inverse.py       |   6 +-
 .../backflow/kernels/backflow_kernel_base.py  |  17 +-
 .../backflow/kernels/backflow_kernel_exp.py   |   9 +-
 .../backflow_kernel_fully_connected.py        |   6 +-
 .../kernels/backflow_kernel_inverse.py        |   9 +-
 .../kernels/backflow_kernel_power_sum.py      |   6 +-
 .../backflow/kernels/backflow_kernel_rbf.py   |  15 +-
 .../kernels/backflow_kernel_square.py         |   6 +-
 .../wavefunction/orbitals/norm_orbital.py     |  36 +++--
 .../wavefunction/orbitals/radial_functions.py | 152 ++++++++++--------
 .../orbitals/spherical_harmonics.py           | 128 ++++++++-------
 14 files changed, 358 insertions(+), 230 deletions(-)

diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index 8729aeb9..58eaf7fb 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-
+from typing import Optional, List
 from .norm_orbital import atomic_orbital_norm
 from .radial_functions import (
     radial_gaussian,
@@ -9,10 +9,10 @@
     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:
@@ -100,7 +100,7 @@ def __init__(self, mol, cuda=False):
         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,
@@ -110,7 +110,7 @@ def __repr__(self):
             self.norb,
         )
 
-    def _to_device(self):
+    def _to_device(self) -> None:
         """Export the non parameter variable to the device."""
 
         self.device = torch.device("cuda")
@@ -128,8 +128,13 @@ def _to_device(self):
             self.__dict__[at] = self.__dict__[at].to(self.device)
 
     def forward(
-        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
-    ):
+        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::
@@ -211,7 +216,7 @@ def forward(
 
         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:
@@ -227,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:
@@ -242,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:
@@ -259,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:
@@ -279,7 +284,12 @@ def _compute_sum_gradient_ao_values(self, pos):
 
         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:
@@ -296,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:
@@ -317,7 +327,12 @@ def _compute_gradient_ao_values(self, pos):
 
         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:
@@ -343,7 +358,7 @@ def _gradient_kernel(self, R, dR, Y, dY):
             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:
@@ -360,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:
@@ -380,7 +395,14 @@ def _compute_sum_diag_hessian_ao_values(self, pos):
         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:
@@ -400,7 +422,7 @@ def _sum_diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
             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:
@@ -430,7 +452,14 @@ def _compute_diag_hessian_ao_values(self, pos):
 
         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:
@@ -463,7 +492,7 @@ def _diag_hessian_kernel(self, R, dR, d2R, Y, dY, d2Y):
 
         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:
@@ -489,21 +518,31 @@ def _compute_mixed_second_derivative_ao_values(self, pos):
 
         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]
@@ -533,19 +572,19 @@ def _off_diag_hessian_kernel(self, R, dR, d2R, d2mR, Y, dY, d2Y, d2mY):
 
         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)
@@ -566,7 +605,7 @@ def _compute_all_ao_values(self, pos):
             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:
@@ -588,7 +627,7 @@ def _process_position(self, pos):
             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:
@@ -609,7 +648,7 @@ def _elec_atom_dist(self, pos):
 
         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:
@@ -626,7 +665,7 @@ def _contract(self, bas):
         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:
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 27041475..2f44fe13 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -1,13 +1,19 @@
 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, 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.
         """
 
@@ -16,8 +22,13 @@ def __init__(self, mol, backflow, cuda=False):
         self.backflow_trans = backflow
 
     def forward(
-        self, pos, derivative=[0], sum_grad=True, sum_hess=True, one_elec=False
-    ):
+        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::
@@ -103,7 +114,7 @@ def forward(
 
         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:
@@ -123,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:
@@ -159,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:
@@ -180,8 +194,12 @@ 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
-    ):
+        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:
@@ -238,7 +256,8 @@ def _compute_diag_hessian_backflow_ao_values(
 
         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:
@@ -287,7 +306,7 @@ def _compute_all_backflow_ao_values(self, pos):
 
         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:
@@ -321,7 +340,7 @@ def _process_position(self, pos):
                 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:
@@ -345,7 +364,7 @@ def _elec_atom_dist(self, pos):
 
         return xyz, r
 
-    def _elec_ao_dist(self, pos):
+    def _elec_ao_dist(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/atoms
 
         Args:
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index c933c726..291761f8 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -1,5 +1,8 @@
 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
 
@@ -7,11 +10,11 @@
 class BackFlowTransformation(nn.Module):
     def __init__(
         self,
-        mol,
-        backflow_kernel,
-        backflow_kernel_kwargs={},
-        orbital_dependent=False,
-        cuda=False,
+        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
@@ -40,7 +43,10 @@ def __init__(
         if self.cuda:
             self.device = torch.device("cuda")
 
-    def forward(self, pos, derivative=0):
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: Optional[int] = 0
+                ) -> torch.Tensor:
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -55,7 +61,9 @@ def forward(self, pos, derivative=0):
                 "derivative of the backflow transformation must be 0, 1 or 2"
             )
 
-    def _get_backflow(self, pos):
+    def _get_backflow(self, 
+                      pos: torch.Tensor
+                      ) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -73,7 +81,7 @@ def _get_backflow(self, pos):
         else:
             return self._backflow(pos)
 
-    def _backflow(self, pos):
+    def _backflow(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -101,7 +109,7 @@ def _backflow(self, pos):
 
         return pos.reshape(-1, self.nelec * self.ndim)
 
-    def _backflow_od(self, pos):
+    def _backflow_od(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the orbital dependent backflow transformation
 
         .. math:
@@ -135,7 +143,7 @@ def _backflow_od(self, pos):
         # retrurn Nbatch x Nao x Nelec*Ndim
         return pos.reshape(nbatch, nao, self.nelec * self.ndim)
 
-    def _get_backflow_derivative(self, pos):
+    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
 
@@ -161,7 +169,7 @@ def _get_backflow_derivative(self, pos):
         else:
             return self._backflow_derivative(pos)
 
-    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
 
@@ -232,7 +240,7 @@ def _backflow_derivative(self, pos):
 
         return out.unsqueeze(-1)
 
-    def _backflow_derivative_od(self, pos):
+    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
 
@@ -308,7 +316,7 @@ def _backflow_derivative_od(self, pos):
 
         return out.permute(0, 2, 3, 4, 5, 1)
 
-    def _get_backflow_second_derivative(self, pos):
+    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
 
@@ -337,7 +345,7 @@ def _get_backflow_second_derivative(self, pos):
         else:
             return self._backflow_second_derivative(pos)
 
-    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
 
@@ -426,7 +434,7 @@ def _backflow_second_derivative(self, pos):
 
         return out.unsqueeze(-1)
 
-    def _backflow_second_derivative_od(self, pos):
+    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
 
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 1ffb230c..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,10 +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
@@ -19,7 +19,7 @@ def __init__(self, mol, cuda, order=2):
 
         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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 3f36892b..5dde3648 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,10 +1,11 @@
 import torch
 from torch import nn
 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
@@ -18,7 +19,7 @@ def __init__(self, mol, cuda):
         if self.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
@@ -40,7 +41,7 @@ def forward(self, ree, derivative=0):
         else:
             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,7 +52,7 @@ def _backflow_kernel(self, ree):
         """
         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:
@@ -68,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:
@@ -87,7 +88,7 @@ def _backflow_kernel_second_derivative(self, ree):
         return hess_val
 
     @staticmethod
-    def _grad(val, ree):
+    def _grad(val, ree: torch.Tensor) -> torch.Tensor:
         """Get the gradients of the kernel.
 
         Args:
@@ -99,7 +100,7 @@ def _grad(val, ree):
         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
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index e194f8af..94fd9a33 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -1,12 +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 BackFlowKernelExp(BackFlowKernelBase):
-    def __init__(self, mol, cuda=False, weight=0.0, alpha=1.0):
+    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
@@ -22,7 +23,7 @@ def __init__(self, mol, cuda=False, weight=0.0, alpha=1.0):
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
         self.alpha = nn.Parameter(torch.as_tensor([alpha])) 
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the backflow kernel:
 
         .. math:
@@ -39,7 +40,7 @@ def _backflow_kernel(self, ree):
         # mask = torch.ones_like(ree) - eye
         return self.weight * torch.exp(-self.alpha * ree)
 
-    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::
@@ -55,7 +56,7 @@ def _backflow_kernel_derivative(self, ree):
         # 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):
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the derivative of the kernel function
             w.r.t r_{ij}
         .. math::
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 9292493f..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,10 +1,10 @@
 import torch
 from torch import nn
 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
@@ -20,7 +20,7 @@ def __init__(self, mol, cuda):
         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 4dc62f28..993faaa2 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -1,12 +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, weight=0.0):
+    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
@@ -21,7 +22,7 @@ def __init__(self, mol, cuda=False, weight=0.0):
         super().__init__(mol, cuda)
         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:
@@ -38,7 +39,7 @@ def _backflow_kernel(self, ree):
         mask = torch.ones_like(ree) - 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::
@@ -55,7 +56,7 @@ def _backflow_kernel_derivative(self, ree):
         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::
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 053f8eee..984b70a9 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -1,9 +1,9 @@
 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
@@ -16,7 +16,7 @@ def __init__(self, mol, cuda, order=2):
         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
index ac0e6d6d..5887be77 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -2,12 +2,13 @@
 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, cuda = False, num_rbf=10):
+    def __init__(self, mol: Molecule, cuda: bool = False, num_rbf: int = 10):
 
         """
         Initialize the RBF kernel
@@ -52,7 +53,7 @@ def __init__(self, mol, cuda = False, num_rbf=10):
 
         self.register_parameter('bias', None)
 
-    def _gaussian_kernel(self, ree):
+    def _gaussian_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         
         '''Compute the RBF kernel
         
@@ -64,7 +65,7 @@ def _gaussian_kernel(self, ree):
         '''
         return torch.exp(-(ree-self.centers)**2 / self.sigma)
     
-    def _gaussian_kernel_derivative(self, ree):
+    def _gaussian_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         '''Compute the derivative of the RBF kernel
         
         Args:
@@ -75,7 +76,7 @@ def _gaussian_kernel_derivative(self, ree):
         '''
         return -2*(ree-self.centers)/self.sigma * self._gaussian_kernel(ree)
     
-    def _gaussian_kernel_second_derivative(self, ree):
+    def _gaussian_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         '''Compute the second derivative of the RBF kernel
         
         Args:
@@ -88,7 +89,7 @@ def _gaussian_kernel_second_derivative(self, ree):
         derivative = self._gaussian_kernel_derivative(ree)
         return -2 / self.sigma * kernel  - 2*(ree-self.centers)/self.sigma * derivative
 
-    def _backflow_kernel(self, ree):
+    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         '''Compute the kernel
         
         Args:
@@ -105,7 +106,7 @@ def _backflow_kernel(self, ree):
         x = x.reshape(*original_shape)
         return x
     
-    def _backflow_kernel_derivative(self, ree):
+    def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Compute the derivative of the kernel
 
         Args:
@@ -119,7 +120,7 @@ def _backflow_kernel_derivative(self, ree):
         x = x.reshape(*original_shape)
         return x
     
-    def _backflow_kernel_second_derivative(self, ree):
+    def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         """Compute the second derivative of the kernel
 
         Args:
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
index 5cbe7f5a..2d4a1e01 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -1,10 +1,10 @@
 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
@@ -12,7 +12,7 @@ def __init__(self, mol, cuda=False):
             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/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index b272488c..e251caf3 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -1,9 +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:
@@ -44,18 +45,20 @@ def atomic_orbital_norm(basis):
             raise ValueError("%s is not a valid radial_type")
 
 
-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
+def norm_slater_spherical(bas_n: torch.Tensor, bas_exp: torch.Tensor) -> torch.Tensor:
+    """Normalization of STOs with Spherical Harmonics.
+
+    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(
         [math.factorial(2 * n) for n in bas_n], dtype=torch.get_default_dtype()
@@ -63,7 +66,7 @@ def norm_slater_spherical(bas_n, bas_exp):
     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.
@@ -87,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
 
@@ -121,7 +129,11 @@ def norm_slater_cartesian(a, b, c, n, exp):
     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
 
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index aa765cdd..ed0f39b3 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -1,10 +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
-):
+    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:
@@ -27,9 +34,6 @@ def radial_slater(
                            (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
@@ -38,11 +42,11 @@ def radial_slater(
     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)
@@ -51,7 +55,7 @@ def _first_derivative_kernel():
         else:
             return nabla_rn * er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
 
-    def _second_derivative_kernel():
+    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)
@@ -74,7 +78,7 @@ def _second_derivative_kernel():
                 + 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."""
 
@@ -120,36 +124,46 @@ def _mixed_second_derivative_kernel():
 
 
 def radial_gaussian(
-    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
-):
+    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)
@@ -157,7 +171,7 @@ def _first_derivative_kernel():
         else:
             return nabla_rn * er.unsqueeze(-1) + rn.unsqueeze(-1) * nabla_er
 
-    def _second_derivative_kernel():
+    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)
@@ -181,7 +195,7 @@ def _second_derivative_kernel():
                 + 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."""
 
@@ -201,7 +215,7 @@ def _mixed_second_derivative_kernel():
             + rn.unsqueeze(-1) * lap_er
         )
 
-    # computes the basic  quantities
+    # computes the basic quantities
     R2 = R * R
     rn = fast_power(R, bas_n)
     er = torch.exp(-bas_exp * R2)
@@ -225,20 +239,26 @@ def _mixed_second_derivative_kernel():
 
 
 def radial_gaussian_pure(
-    R, bas_n, bas_exp, xyz=None, derivative=[0], sum_grad=True, sum_hess=True
-):
+    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
@@ -247,7 +267,7 @@ def radial_gaussian_pure(
                            (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):
@@ -301,44 +321,50 @@ def _mixed_second_derivative_kernel():
 
 
 def radial_slater_pure(
-    R, bas_n, bas_exp, xyz=None, derivative=0, sum_grad=True, sum_hess=True
-):
+    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.0 / R)
 
@@ -349,7 +375,7 @@ def _second_derivative_kernel():
             )
             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."""
 
@@ -381,27 +407,27 @@ def _mixed_second_derivative_kernel():
 
 
 def return_required_data(
-    derivative,
-    _kernel,
-    _first_derivative_kernel,
-    _second_derivative_kernel,
-    _mixed_second_derivative_kernel,
-):
+    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 = [
+    output: List = []
+    fns: List[Callable] = [
         _kernel,
         _first_derivative_kernel,
         _second_derivative_kernel,
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 01127598..7b63dab8 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -1,9 +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:
@@ -55,25 +56,29 @@ def __init__(self, type, **kwargs):
             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":
@@ -91,37 +96,44 @@ def __call__(self, xyz, derivative=[0], sum_grad=True, sum_hess=True):
                 xyz, self.bas_l, self.bas_m, derivative, sum_grad, sum_hess
             )
         else:
-            raise ValueError("Harmonics type should be cart or sph")
+            raise ValueError("Harmonics type should be 'cart' or 'sph'")
 
 
 def CartesianHarmonics(
-    xyz, k, mask0, mask2, derivative=[0], sum_grad=True, sum_hess=True
-):
+    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():
+    def _first_derivative_kernel() -> torch.Tensor:
         km1 = k - 1
         km1[km1 < 0] = 0
 
@@ -137,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
 
@@ -155,7 +166,7 @@ def _second_derivative_kernel():
         else:
             return torch.stack((d2x, d2y, d2z), dim=-1)
 
-    def _mixed_second_derivative_kernel():
+    def _mixed_second_derivative_kernel() -> torch.Tensor:
         km1 = k - 1
         km1[km1 < 0] = 0
 
@@ -169,10 +180,8 @@ def _mixed_second_derivative_kernel():
 
         return torch.stack((dxdy, dxdz, dydz), dim=-1)
 
-    # computes the power of the xyz
     xyz_k = fast_power(xyz, k, mask0, mask2)
 
-    # compute the outputs
     fns = [
         _kernel,
         _first_derivative_kernel,
@@ -190,19 +199,29 @@ 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(
@@ -225,7 +244,7 @@ def SphericalHarmonics(xyz, l, m, derivative=0, sum_grad=True, sum_hess=True):
         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:
@@ -233,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
@@ -283,13 +303,13 @@ def get_spherical_harmonics(xyz, lval, m, derivative):
     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:
@@ -328,7 +348,7 @@ def get_grad_spherical_harmonics(xyz, lval, m):
 # =============== 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)
@@ -339,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)
@@ -349,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)
@@ -359,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)
@@ -372,7 +392,7 @@ def _lap_spherical_harmonics_l0(xyz):
 # =============== 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)
@@ -388,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)
@@ -405,7 +425,7 @@ def _nabla_spherical_harmonics_l1(xyz, m):
     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)
@@ -456,7 +476,7 @@ def _grad_spherical_harmonics_l1(xyz, m):
         )
 
 
-def _lap_spherical_harmonics_l1(xyz, m):
+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)
@@ -476,7 +496,7 @@ def _lap_spherical_harmonics_l1(xyz, m):
 # =============== 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)
@@ -507,7 +527,7 @@ def _spherical_harmonics_l2(xyz, m):
         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)
@@ -553,7 +573,7 @@ def _nabla_spherical_harmonics_l2(xyz, m):
         )
 
 
-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)
@@ -637,7 +657,7 @@ def _grad_spherical_harmonics_l2(xyz, m):
         )
 
 
-def _lap_spherical_harmonics_l2(xyz, m):
+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)

From f449f979b6a82d8de8b9cc63807d92ef5c16b47d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 16:18:56 +0100
Subject: [PATCH 251/286] fix syntax issus

---
 H2.xyz                                                    | 4 ++++
 qmctorch/solver/solver.py                                 | 8 ++++----
 qmctorch/solver/solver_base.py                            | 4 ++--
 qmctorch/solver/solver_mpi.py                             | 2 +-
 qmctorch/utils/torch_utils.py                             | 4 +---
 qmctorch/wavefunction/orbitals/atomic_orbitals.py         | 4 ++--
 .../backflow/kernels/backflow_kernel_power_sum.py         | 1 +
 qmctorch/wavefunction/wf_base.py                          | 2 +-
 8 files changed, 16 insertions(+), 13 deletions(-)
 create mode 100644 H2.xyz

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/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 87f90c3f..9f210fd6 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -2,7 +2,7 @@
 from time import time
 from tqdm import tqdm
 from types import SimpleNamespace
-from typing import Optional, Dict, Union, List, bool, Tuple, Any
+from typing import Optional, Dict, Union, List, Tuple, Any
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
 import torch
@@ -340,7 +340,7 @@ def run_epochs(self, nepoch: int,
 
         return cumulative_loss
 
-    def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple(torch.Tensor, torch.Tensor):
+    def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Evaluate the gradient using automatic differentiation
 
         Args:
@@ -362,7 +362,7 @@ def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple(torch.Tensor, torch.Te
 
         return loss, eloc
 
-    def evaluate_grad_manual(self, lpos: torch.Tensor) -> Tuple(torch.Tensor, torch.Tensor):
+    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 
@@ -412,7 +412,7 @@ def evaluate_grad_manual(self, lpos: torch.Tensor) -> Tuple(torch.Tensor, torch.
         else:
             raise ValueError("Manual gradient only for energy minimization")
         
-    def evaluate_grad_manual_2(self, lpos: torch.Tensor) -> Tuple(torch.Tensor, torch.Tensor):
+    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 
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 3e9e181e..d919560d 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -1,5 +1,5 @@
 from types import SimpleNamespace
-from typing import Optional, Dict, Union, List, bool, Tuple, Any
+from typing import Optional, Dict, Union, List, Tuple, Any
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
 import os
@@ -398,7 +398,7 @@ def save_checkpoint(self, epoch: int , loss: float):
             filename,
         )
 
-    def load_checkpoint(self, filename: str) -> Tuple(int, float):
+    def load_checkpoint(self, filename: str) -> Tuple[int, float]:
         """load a model/optmizer
 
         Args:
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 40217d5b..3d65d4d1 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -1,6 +1,6 @@
 from time import time
 from types import SimpleNamespace
-from typing import Optional, Dict, Union, List, bool, Tuple, Any
+from typing import Optional, Dict, Union, List, Tuple, Any
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
 
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index b44f8aac..d2ba0b26 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -5,8 +5,6 @@
 from torch.utils.data import Dataset
 from math import ceil
 
-from ..wavefunction import Wavefunction
-
 
 def set_torch_double_precision() -> None:
     """Set the default precision to double for all torch tensors."""
@@ -204,7 +202,7 @@ def __next__(self) -> torch.Tensor:
 
 class Loss(nn.Module):
     def __init__(self, 
-                 wf: Wavefunction, 
+                 wf, 
                  method: str = "energy", 
                  clip: bool = False):
         """Defines the loss to use during the optimization
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index 58eaf7fb..1b375c58 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from typing import Optional, List
+from typing import Optional, List, Tuple
 from .norm_orbital import atomic_orbital_norm
 from .radial_functions import (
     radial_gaussian,
@@ -627,7 +627,7 @@ def _process_position(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tens
             r.repeat_interleave(self.nshells, dim=2),
         )
 
-    def _elec_atom_dist(self, pos: torch.Tensor) -> Tuple(torch.Tensor, torch.Tensor):
+    def _elec_atom_dist(self, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the positions/distance bewteen elec/atoms
 
         Args:
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 984b70a9..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,3 +1,4 @@
+import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index 45dfa42f..b70ffccc 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -1,6 +1,6 @@
 import h5py
 import torch
-from typing import Optional, bool
+from typing import Optional
 from torch.autograd import Variable, grad
 
 

From a6a3ba8ee922492db8b4e224c81a031c26dc2103 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 16:41:32 +0100
Subject: [PATCH 252/286] fix pint bug

---
 qmctorch/sampler/pints_sampler.py             |   2 +
 .../pooling/orbital_configurations.py         | 139 +++++++++++-------
 .../wavefunction/pooling/orbital_projector.py |  45 ++++--
 3 files changed, 118 insertions(+), 68 deletions(-)

diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index d1ebe480..bd8cfa0f 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -13,6 +13,8 @@ def __init__(self, pdf: Callable[[torch.Tensor], torch.Tensor], ndim: int) -> No
             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
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 8061b290..b6322479 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -1,24 +1,24 @@
 import torch
-
+from typing import Tuple, List
+from ...scf import Molecule
 
 class OrbitalConfigurations:
-    def __init__(self, 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 configurations 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):
@@ -56,14 +56,13 @@ def get_configs(self, configs):
             print("              cas(nelec,norb)")
             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")
@@ -71,28 +70,31 @@ def sanity_check(self, nelec, norb):
         if norb > self.norb:
             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))
@@ -117,7 +119,10 @@ def _get_single_config(self, nocc, nvirt):
 
         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:
@@ -168,7 +173,11 @@ def _get_single_double_config(self, nocc, nvirt):
 
         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:
@@ -202,7 +211,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 ___
@@ -224,21 +233,32 @@ def _get_orb_number(self, nelec, norb):
         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
@@ -247,51 +267,58 @@ 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])):
@@ -320,21 +347,21 @@ def get_excitation(configs):
     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 = [], []
@@ -365,4 +392,4 @@ def get_unique_excitation(configs):
         index_uniq_exc_up.append(uniq_exc_up.index(exc_up))
         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 481040e9..40560859 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -1,12 +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
         """
@@ -21,8 +25,15 @@ def __init__(self, configs, mol, cuda=False):
         if cuda:
             self.device = torch.device("cuda")
         self.unique_configs, self.index_unique_configs = self.get_unique_configs()
-    def get_unique_configs(self):
+    def get_unique_configs(self) -> Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]:
         """Get the unique configurations
+
+        Returns:
+            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)
@@ -30,16 +41,20 @@ def get_unique_configs(self):
         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))
 
 
-    def split_orbitals(self, mat, unique_configs=False):
-        """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
-            unique_confgs (bool, optional): compute only the slater matrices of the unique conf if True (Defaulta False)
+            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 mat.ndim == 3:
             nbatch = mat.shape[0]
@@ -67,7 +82,13 @@ def split_orbitals(self, mat, unique_configs=False):
         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:
@@ -89,7 +110,7 @@ def __init__(self, unique_excitations, mol, max_orb, cuda=False):
         if 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."""
 
@@ -130,7 +151,7 @@ def get_index_unique_single(self):
             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

From 55859b7e37d7c2a37fab1ed8986ee3bd9e522ceb Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 16:53:30 +0100
Subject: [PATCH 253/286] hins on slater

---
 .../wavefunction/pooling/slater_pooling.py    | 231 ++++++++++++------
 1 file changed, 159 insertions(+), 72 deletions(-)

diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index dd48ae3c..043a3605 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -2,6 +2,8 @@
 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.
 
@@ -53,14 +62,14 @@ def __init__(self, config_method, configs, mol, cuda=False):
         if 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("):
             return self.det_explicit(input)
@@ -69,19 +78,21 @@ def forward(self, input):
                 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, 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:
@@ -95,38 +106,39 @@ def det_explicit(self, input):
         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 excitation
+        # Compute the determinant of the unique single and double excitations
         det_unique_up, det_unique_down = self.det_unique_single_double(input)
 
-        # returns the product of spin up/down required by each excitation
+        # 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]]
         )
 
-    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).
 
+        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
@@ -239,18 +251,25 @@ def det_unique_single_double(self, input):
 
         return det_out_up, det_out_down
 
-    def operator(self, mo, bop, op=op.add, op_squared=False, inv_mo=None):
+    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
             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
@@ -276,17 +295,23 @@ def operator(self, mo, bop, op=op.add, op_squared=False, inv_mo=None):
         else:
             return op_vals
 
-    def operator_ground_state(self, mo, bop, op_squared=False, inv_mo=None):
+    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
         """
         if inv_mo is None:
             invAup, invAdown = self.compute_inverse_occupied_mo_matrix(mo)
@@ -310,7 +335,12 @@ def operator_ground_state(self, mo, bop, op_squared=False, inv_mo=None):
 
         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.
 
@@ -319,12 +349,12 @@ 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
@@ -363,20 +393,28 @@ 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[..., self.orb_proj.index_unique_configs[0]], 
-                op_val_down[..., self.orb_proj.index_unique_configs[1]])
+        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, bop, op_squared=False, inv_mo=None):
+    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
-            inv_mo (tuple, optional): precomputed inverse of the up/down MO matrices
+            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, inv_mo)
@@ -386,16 +424,25 @@ def operator_single_double(self, mo, bop, op_squared=False, inv_mo=None):
             op_down[..., self.index_unique_excitation[1]],
         )
 
-    def operator_unique_single_double(self, mo, bop, op_squared, inv_mo):
+    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"):
@@ -584,7 +631,13 @@ def operator_unique_single_double(self, mo, bop, op_squared, inv_mo):
             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::
@@ -593,11 +646,14 @@ 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
@@ -612,7 +668,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::
@@ -621,12 +684,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
@@ -653,7 +718,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::
@@ -663,12 +735,14 @@ 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
@@ -688,7 +762,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::
@@ -702,9 +784,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
@@ -736,7 +820,10 @@ def op_squared_multiexcitation(baseterm, mat_exc, M, Y, index, size, nbatch):
         return op_vals
     
 
-    def compute_inverse_occupied_mo_matrix(self, mo: torch.tensor) -> tuple:
+    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:

From 642e7f41ae698433406dbe41bdd79e69fcae9eb2 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 16:59:20 +0100
Subject: [PATCH 254/286] fix syntax

---
 qmctorch/wavefunction/pooling/slater_pooling.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 043a3605..a03fdc73 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -138,7 +138,7 @@ def det_ground_state(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Ten
             torch.det(input[:, self.nup :, : self.ndown]),
         )
 
-    def det_unique_single_double(self, input: torch.Tensor) -> Tuple(torch.Tensor, torch.Tensor):
+    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

From bd8465506566a1cdea2a0204a3e5d579a64481eb Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 17:53:15 +0100
Subject: [PATCH 255/286] hints on jastrow

---
 .../distance/electron_electron_distance.py    | 42 +++++++++-------
 .../distance/electron_nuclei_distance.py      | 44 ++++++++++-------
 .../wavefunction/jastrows/distance/scaling.py |  6 +--
 .../jastrow_factor_electron_electron.py       | 48 +++++++++++--------
 .../kernels/fully_connected_jastrow_kernel.py | 34 ++++++++-----
 .../jastrow_kernel_electron_electron_base.py  | 14 +++---
 .../elec_elec/kernels/pade_jastrow_kernel.py  | 10 ++--
 .../kernels/pade_jastrow_polynomial_kernel.py | 21 ++++----
 ...jastrow_factor_electron_electron_nuclei.py | 42 ++++++++++------
 .../kernels/boys_handy_jastrow_kernel.py      | 11 +++--
 .../kernels/fully_connected_jastrow_kernel.py | 12 +++--
 ...ow_kernel_electron_electron_nuclei_base.py | 18 ++++---
 .../jastrow_factor_electron_nuclei.py         | 28 ++++++++---
 .../kernels/fully_connected_jastrow_kernel.py | 27 ++++++-----
 .../jastrow_kernel_electron_nuclei_base.py    | 14 +++---
 .../kernels/pade_jastrow_kernel.py            |  8 ++--
 .../jastrows/graph/elec_elec_graph.py         |  6 +--
 .../jastrows/graph/elec_nuc_graph.py          |  8 ++--
 .../jastrows/graph/mgcn_jastrow.py            | 37 +++++++-------
 19 files changed, 258 insertions(+), 172 deletions(-)

diff --git a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 9c8a776a..df95a16f 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -8,7 +8,12 @@
 
 
 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::
@@ -16,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)
@@ -41,9 +47,13 @@ def __init__(self, nelec, ndim=3, scale=False, scale_factor=0.6):
         elif _type_ == torch.float64:
             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.
 
@@ -56,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
 
         """
@@ -98,7 +108,7 @@ def forward(self, input, derivative=0):
             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:
@@ -122,7 +132,7 @@ def safe_sqrt(self, dist):
 
         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::
@@ -145,7 +155,7 @@ def get_der_distance(self, pos, dist):
         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::
@@ -170,7 +180,7 @@ def get_second_der_distance(self, pos, dist):
         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:
@@ -185,7 +195,7 @@ def get_distance_quadratic(pos):
         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 a4a74957..20b0cbee 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,5 +1,6 @@
 import torch
 from torch import nn
+from typing import Optional, Tuple, Union
 from .scaling import (
     get_scaled_distance,
     get_der_scaled_distance,
@@ -8,7 +9,14 @@
 
 
 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::
@@ -16,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,
@@ -29,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
 
         """
 
@@ -83,7 +93,7 @@ def forward(self, input, derivative=0):
             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::
@@ -103,7 +113,7 @@ def get_der_distance(self, pos, dist):
         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::
@@ -127,7 +137,7 @@ def get_second_der_distance(self, pos, dist):
         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:
diff --git a/qmctorch/wavefunction/jastrows/distance/scaling.py b/qmctorch/wavefunction/jastrows/distance/scaling.py
index 070b6f32..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::
@@ -19,7 +19,7 @@ def get_scaled_distance(kappa, r):
     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::
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 7ec373d7..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,21 +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,
-        mol,
-        jastrow_kernel,
-        kernel_kwargs={},
-        orbital_dependent_kernel=False,
-        number_of_orbitals=None,
-        scale=False,
-        scale_factor=0.6,
-        cuda=False,
-    ):
+        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::
@@ -75,15 +77,17 @@ def __init__(
             self.nelec, self.ndim, scale=scale, scale_factor=scale_factor
         )
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """representation of the jastrow factor"""
         return "ee -> " + self.jastrow_kernel.__class__.__name__
 
-    def get_mask_tri_up(self):
-        r"""Get the mask to select the triangular up matrix
+    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)
         index_col, index_row = [], []
@@ -97,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:
@@ -109,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:
@@ -135,7 +139,11 @@ def get_edist_unique(self, pos, derivative=0):
                 nbatch, 3, -1
             )
 
-    def forward(self, pos, derivative=0, sum_grad=True):
+    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:
@@ -186,7 +194,7 @@ def forward(self, pos, derivative=0, sum_grad=True):
                 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:
@@ -223,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:
@@ -254,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/fully_connected_jastrow_kernel.py b/qmctorch/wavefunction/jastrows/elec_elec/kernels/fully_connected_jastrow_kernel.py
index 9b24d53b..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
@@ -6,15 +6,25 @@
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronBase):
     def __init__(
         self,
-        nup,
-        ndown,
-        cuda,
-        size1=16,
-        size2=8,
-        activation=torch.nn.Sigmoid(),
-        include_cusp_weight=True,
-    ):
-        """Defines a fully connected jastrow factors."""
+        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.
+
+        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)
 
@@ -40,7 +50,7 @@ def __init__(
 
         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
@@ -59,7 +69,7 @@ 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:
@@ -93,7 +103,7 @@ def get_static_weight(self):
 
         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 5875b122..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,10 +1,10 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-
+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:
@@ -22,7 +22,7 @@ def __init__(self, nup, ndown, cuda, **kwargs):
 
         self.requires_autograd = True
 
-    def forward(self, r):
+    def forward(self, r: torch.Tensor):
         r"""Get the elements of the jastrow matrix :
 
 
@@ -50,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
 
@@ -74,7 +74,7 @@ def compute_derivative(self, r, dr):
 
         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
 
@@ -106,7 +106,7 @@ def compute_second_derivative(self, r, dr, 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
 
@@ -119,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
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 eddeeffd..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,7 +6,7 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronElectronBase):
-    def __init__(self, nup, ndown, cuda, w=1.0):
+    def __init__(self, nup: int, ndown: int, cuda: bool, w: float = 1.0) -> None:
         """Computes the Simple Pade-Jastrow factor
 
         .. math::
@@ -31,7 +31,7 @@ def __init__(self, nup, ndown, cuda, w=1.0):
         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:
@@ -65,7 +65,7 @@ def get_static_weight(self):
 
         return static_weight
 
-    def forward(self, r):
+    def forward(self, r: torch.Tensor) -> torch.Tensor:
         """Get the jastrow kernel.
 
         .. math::
@@ -81,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
 
@@ -116,7 +116,7 @@ def compute_derivative(self, r, dr):
 
         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
 
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 e3f8bb93..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,12 +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::
@@ -40,7 +41,7 @@ def __init__(self, nup, ndown, cuda, order=2, weight_a=None, weight_b=None):
         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:
@@ -74,7 +75,7 @@ def get_static_weight(self):
 
         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:
@@ -102,7 +103,7 @@ def set_variational_weights(self, weight_a, weight_b):
         register_extra_attributes(self, ["weight_a"])
         register_extra_attributes(self, ["weight_b"])
 
-    def forward(self, r):
+    def forward(self, r: torch.Tensor) -> torch.Tensor:
         """Get the jastrow kernel.
 
         .. math::
@@ -122,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
 
@@ -170,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
 
@@ -210,7 +211,7 @@ def compute_second_derivative(self, r, dr, d2r):
 
         return out
 
-    def _compute_polynoms(self, r):
+    def _compute_polynoms(self, r: torch.Tensor) -> torch.Tensor:
         """Compute the num and denom polynomials.
 
         Args:
@@ -233,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:
@@ -262,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:
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 0d0eee9e..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,13 +1,19 @@
 import torch
 from torch import nn
 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, mol, 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::
@@ -62,7 +68,7 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         # 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:
@@ -80,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:
@@ -93,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:
@@ -113,7 +119,7 @@ def extract_elec_nuc_dist(self, en_dist):
         else:
             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:
@@ -136,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}]
@@ -163,7 +169,7 @@ 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")
@@ -173,7 +179,7 @@ def _to_device(self):
             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:
@@ -238,7 +244,7 @@ def forward(self, pos, derivative=0, sum_grad=True):
         else:
             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:
@@ -299,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:
@@ -340,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:
@@ -361,7 +372,10 @@ def partial_derivative(self, djast):
 
         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
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 0ec75e3f..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
@@ -7,8 +7,13 @@
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
     def __init__(
-        self, nup, ndown, atomic_pos, cuda, nterm=5
-    ):  # pylint: disable=too-many-arguments
+        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
@@ -35,7 +40,7 @@ def __init__(
         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:
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 ad0ed97c..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
@@ -5,9 +5,15 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda):
-        """Defines a fully connected jastrow factors."""
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool)-> None:
+        """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)
@@ -24,7 +30,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda):
 
         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 b2042712..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,17 +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
@@ -30,7 +28,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
             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:
@@ -44,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)
@@ -56,7 +54,7 @@ def compute_derivative(self, r, dr):
         # sum over the atoms
         return out
 
-    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."""
 
         dr2 = dr * dr
@@ -69,7 +67,7 @@ def compute_second_derivative(self, r, dr, 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
 
@@ -82,7 +80,7 @@ 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:
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 db21a73a..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,10 +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, mol, 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::
@@ -44,11 +51,15 @@ def __init__(self, mol, jastrow_kernel, kernel_kwargs={}, cuda=False):
         # elec-nuc distances
         self.edist = ElectronNucleiDistance(self.nelec, self.atoms, self.ndim)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """representation of the jastrow factor"""
         return "en -> " + self.jastrow_kernel.__class__.__name__
 
-    def forward(self, pos, derivative=0, sum_grad=True):
+    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:
@@ -99,7 +110,7 @@ def forward(self, pos, derivative=0, sum_grad=True):
                 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:
@@ -118,7 +129,12 @@ def jastrow_factor_derivative(self, r, dr, jast, sum_grad):
             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:
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 d9e5bd69..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,31 +5,34 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
+    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):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Get the jastrow kernel.
 
         Args:
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 d0890f3e..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,10 +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::
@@ -31,7 +31,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, **kwargs):
             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}} }
@@ -46,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
 
@@ -77,7 +77,7 @@ def compute_derivative(self, r, dr):
 
         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
 
@@ -115,7 +115,7 @@ def compute_second_derivative(self, r, dr, 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
 
@@ -128,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
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 ca0b4159..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,7 +6,7 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
+    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::
@@ -31,7 +31,7 @@ def __init__(self, nup, ndown, atomic_pos, cuda, w=1.0):
         self.static_weight = torch.as_tensor([1.0]).to(self.device)
         self.requires_autograd = True
 
-    def forward(self, r):
+    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
 
@@ -76,7 +76,7 @@ def compute_derivative(self, r, dr):
 
         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
 
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index 35a8f7f9..f7d1467f 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -2,7 +2,7 @@
 import torch
 
 
-def ElecElecGraph(nelec, nup):
+def ElecElecGraph(nelec: int, nup: int) -> dgl.DGLGraph:
     """Create the elec-elec graph
 
     Args:
@@ -18,7 +18,7 @@ def ElecElecGraph(nelec, nup):
     return graph
 
 
-def get_elec_elec_edges(nelec):
+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):
@@ -32,7 +32,7 @@ def get_elec_elec_edges(nelec):
     return ee_edges
 
 
-def get_elec_elec_ndata(nelec, nup):
+def get_elec_elec_ndata(nelec:int , nup: int) -> torch.Tensor:
     """Compute the node data of the elec-elec graph"""
 
     ee_ndata = []
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 0cb22dc8..2d136a54 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -3,7 +3,7 @@
 from mendeleev import element
 
 
-def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
+def ElecNucGraph(natoms:int, atom_types:list, atomic_features:list, nelec:int, nup:int) -> dgl.DGLGraph:
     """Create the elec-nuc graph
 
     Args:
@@ -21,7 +21,7 @@ def ElecNucGraph(natoms, atom_types, atomic_features, nelec, nup):
     return graph
 
 
-def get_elec_nuc_edges(natoms, nelec):
+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):
@@ -39,7 +39,7 @@ def get_elec_nuc_edges(natoms, nelec):
     return en_edges
 
 
-def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
+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 = []
@@ -68,7 +68,7 @@ def get_elec_nuc_ndata(natoms, atom_types, atomic_features, nelec, nup):
     return torch.LongTensor(en_ndata)
 
 
-def get_atomic_features(atom_type, atomic_features):
+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)
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
index 33dadaa4..40a896b9 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -1,6 +1,7 @@
 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
@@ -8,17 +9,17 @@
 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,
-        ee_model_kwargs={},
-        en_model_kwargs={},
-        atomic_features=["atomic_number"],
-        cuda=False,
-    ):
+        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:
@@ -78,11 +79,15 @@ def __init__(
             self.natoms, self.atom_types, self.atomic_features, self.nelec, self.nup
         )
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """representation of the jastrow factor"""
         return "ee, en graph -> " + self.__class__.__name__
 
-    def forward(self, pos, derivative=0, sum_grad=True):
+    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:
@@ -142,7 +147,7 @@ def forward(self, pos, derivative=0, sum_grad=True):
                 pos, ee_kernel, en_kernel, sum_grad=sum_grad, return_all=True
             )
 
-    def _get_val(self, ee_kernel, en_kernel):
+    def _get_val(self, ee_kernel: torch.Tensor, en_kernel: torch.Tensor) -> torch.Tensor:
         """Get the jastrow values.
 
         Args:
@@ -151,7 +156,7 @@ def _get_val(self, ee_kernel, en_kernel):
         """
         return torch.exp(ee_kernel + en_kernel)
 
-    def _get_grad_vals(self, pos, ee_kernel, en_kernel, sum_grad):
+    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
 
 
@@ -175,8 +180,8 @@ def _get_grad_vals(self, pos, ee_kernel, en_kernel, sum_grad):
         return grad_val
 
     def _get_hess_vals(
-        self, pos, ee_kernel, en_kernel, sum_grad=False, return_all=False
-    ):
+        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:
@@ -227,7 +232,7 @@ def _get_hess_vals(
         else:
             return hval
 
-    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:
@@ -245,7 +250,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:
@@ -258,7 +263,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, ren):
+    def extract_elec_nuc_dist(self, ren: torch.Tensor) -> torch.Tensor:
         """reorganizre the elec-nuc distance to load them in the graph
 
         Args:

From df5c0867585f66f44e84b8ada2cb31d14328779f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 18:16:52 +0100
Subject: [PATCH 256/286] hints for orbital dependent

---
 .../orbital_dependent_backflow_kernel.py      | 12 ++++--
 ...bital_dependent_backflow_transformation.py | 18 ++++++---
 .../slater_orbital_dependent_jastrow.py       | 40 ++++++++++---------
 3 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 92f9eef9..ad5aaf4b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -1,9 +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
@@ -33,7 +39,7 @@ def __init__(self, backflow_kernel, backflow_kernel_kwargs, mol, cuda):
         # 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 18f8f587..b079c3ff 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -1,11 +1,17 @@
 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
@@ -28,7 +34,7 @@ def __init__(self, mol, backflow_kernel, backflow_kernel_kwargs={}, cuda=False):
         if self.cuda:
             self.device = torch.device("cuda")
 
-    def forward(self, pos, derivative=0):
+    def forward(self, pos: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         if derivative == 0:
             return self._backflow(pos)
 
@@ -43,7 +49,7 @@ def forward(self, pos, derivative=0):
                 "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:
@@ -77,7 +83,7 @@ def _backflow(self, pos):
         # retrurn Nbatch x Nao x Nelec*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
 
@@ -151,7 +157,7 @@ def _backflow_derivative(self, pos):
         # 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
 
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index e1b5e2d4..52f0e1c4 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -1,24 +1,26 @@
 import torch
 import operator
-
+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,
 )
+from  ..scf import Molecule
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
     def __init__(
         self,
-        mol,
-        configs="ground_state",
-        kinetic="jacobi",
-        jastrow_kernel=PadeJastrowKernel,
-        jastrow_kernel_kwargs={},
-        cuda=False,
-        include_all_mo=True,
-    ):
+        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::
@@ -75,7 +77,7 @@ def __init__(
 
         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:
@@ -95,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)
@@ -107,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::
@@ -151,13 +153,13 @@ def forward(self, x, ao=None):
         # compute the CI and return
         return self.fc(x)
 
-    def ao2mo(self, ao):
+    def ao2mo(self, ao: torch.Tensor) -> torch.Tensor:
         return self.mo(self.mo_scf(ao))
 
     def ao2cmo(self, ao, jastrow):
         return jastrow * self.mo(self.mo_scf(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)
@@ -166,7 +168,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:
@@ -217,7 +219,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 .
 
@@ -262,7 +264,7 @@ def kinetic_energy_jacobi(self, x, **kwargs):
         # 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:
@@ -296,7 +298,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:
@@ -348,7 +350,7 @@ def get_hessian_operator(self, x):
 
         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:

From 4620029502262b0cefe7696149f0fe8094c9d67f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 18:50:08 +0100
Subject: [PATCH 257/286] move Loss to Solver

---
 qmctorch/solver/loss.py       | 145 ++++++++++++++++++++++++++++++++
 qmctorch/solver/solver.py     |   7 +-
 qmctorch/solver/solver_mpi.py |   4 +-
 qmctorch/utils/__init__.py    |   2 -
 qmctorch/utils/torch_utils.py | 151 ++--------------------------------
 5 files changed, 155 insertions(+), 154 deletions(-)
 create mode 100644 qmctorch/solver/loss.py

diff --git a/qmctorch/solver/loss.py b/qmctorch/solver/loss.py
new file mode 100644
index 00000000..856a50e8
--- /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):
+        """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 = 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: 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)
+            emax = median + self.clip_num_std * std
+            emin = median - self.clip_num_std * std
+            mask = (local_energies < emax) & (local_energies > emin)
+        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 9f210fd6..6c682c08 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -3,14 +3,13 @@
 from tqdm import tqdm
 from types import SimpleNamespace
 from typing import Optional, Dict, Union, List, Tuple, Any
+import torch
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
-import torch
-from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
-
+from ..utils import  OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 from .. import log
 from .solver_base import SolverBase
-
+from .loss import Loss
 
 class Solver(SolverBase):
     def __init__(  # pylint: disable=too-many-arguments
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 3d65d4d1..88d0780d 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -5,8 +5,8 @@
 from ..sampler import SamplerBase
 
 import torch
-from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
-
+from ..utils import DataLoader, OrthoReg, add_group_attr, dump_to_hdf5
+from .loss import Loss
 from .. import log
 from .solver import Solver
 
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index a81cdea5..9bb05559 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -21,7 +21,6 @@
 from .torch_utils import (
     DataSet,
     DataLoader,
-    Loss,
     OrthoReg,
     fast_power,
     set_torch_double_precision,
@@ -34,7 +33,6 @@
     "set_torch_double_precision",
     "set_torch_single_precision",
     "DataSet",
-    "Loss",
     "OrthoReg",
     "DataLoader",
     "add_group_attr",
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index d2ba0b26..04a41977 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -134,7 +134,7 @@ def __len__(self) -> int:
         """
         return self.data.shape[0]
 
-    def __getitem__(self, index) -> torch.Tensor:
+    def __getitem__(self, index: int) -> torch.Tensor:
         """returns a given data point
 
         Arguments:
@@ -148,7 +148,9 @@ def __getitem__(self, index) -> torch.Tensor:
 
 class DataLoader:
     def __init__(
-        self, data: torch.Tensor, batch_size: int, pin_memory: bool = False
+        self, data: torch.Tensor, 
+        batch_size: int, 
+        pin_memory: bool = False
     ) -> None:
         """Simple DataLoader to replace torch data loader
 
@@ -198,150 +200,7 @@ def __next__(self) -> torch.Tensor:
             return out
         else:
             raise StopIteration
-
-
-class Loss(nn.Module):
-    def __init__(self, 
-                 wf, 
-                 method: str = "energy", 
-                 clip: bool = 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})
-        """
-
-        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: 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)
-            emax = median + self.clip_num_std * std
-            emin = median - self.clip_num_std * std
-            mask = (local_energies < emax) & (local_energies > emin)
-        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)
-
-
+        
 class OrthoReg(nn.Module):
     """add a penalty to make matrice orthgonal."""
 

From 35370ad5a828aba3e9cee132c6f2e8647bb2f9fe Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 18:51:50 +0100
Subject: [PATCH 258/286] black

---
 docs/conf.py                                  | 146 ++++----
 docs/example/ase/h2.py                        |  32 +-
 docs/example/ase/h2_cc.py                     |  12 +-
 docs/example/autocorrelation/h2.py            |  28 +-
 docs/example/backflow/backflow.py             |  27 +-
 docs/example/gpu/h2.py                        |  65 ++--
 docs/example/graph/h2.py                      |  70 ++--
 docs/example/graph/jast_graph.py              |  10 +-
 docs/example/horovod/h2.py                    |  69 ++--
 docs/example/optimization/h2.py               |  59 +--
 docs/example/scf/scf.py                       |  26 +-
 docs/example/single_point/h2.py               |  26 +-
 docs/example/single_point/h2o_sampling.py     |  29 +-
 h5x/baseimport.py                             |  12 +-
 qmctorch/__version__.py                       |   2 +-
 qmctorch/ase/__init__.py                      |   2 +-
 qmctorch/ase/ase.py                           | 349 +++++++++++-------
 qmctorch/ase/optimizer/__init__.py            |   2 +-
 qmctorch/ase/optimizer/torch_optim.py         |  62 ++--
 qmctorch/sampler/generalized_metropolis.py    |  17 +-
 qmctorch/sampler/hamiltonian.py               |  28 +-
 qmctorch/sampler/metropolis_all_elec.py       |   5 +-
 .../sampler/metropolis_hasting_all_elec.py    |   5 +-
 qmctorch/sampler/pints_sampler.py             |   6 +-
 qmctorch/sampler/proposal_kernels.py          |   3 +-
 qmctorch/sampler/sampler_base.py              |   4 +-
 .../state_dependent_normal_proposal.py        |   8 +-
 qmctorch/scf/calculator/adf.py                |  14 +-
 qmctorch/scf/molecule.py                      |   2 +-
 qmctorch/solver/loss.py                       |  17 +-
 qmctorch/solver/solver.py                     |  75 ++--
 qmctorch/solver/solver_base.py                |  46 ++-
 qmctorch/solver/solver_mpi.py                 |  26 +-
 qmctorch/utils/algebra_utils.py               |   3 +-
 qmctorch/utils/constants.py                   |   2 +-
 qmctorch/utils/hdf5_utils.py                  |   1 +
 qmctorch/utils/interpolate.py                 |  38 +-
 qmctorch/utils/plot_data.py                   |  31 +-
 qmctorch/utils/provenance.py                  |  10 +-
 qmctorch/utils/stat_utils.py                  |   7 +-
 qmctorch/utils/torch_utils.py                 |  25 +-
 .../distance/electron_electron_distance.py    |  27 +-
 .../distance/electron_nuclei_distance.py      |   8 +-
 .../wavefunction/jastrows/distance/scaling.py |   8 +-
 .../jastrow_factor_electron_electron.py       |  27 +-
 .../jastrow_kernel_electron_electron_base.py  |   9 +-
 .../elec_elec/kernels/pade_jastrow_kernel.py  |   4 +-
 .../kernels/pade_jastrow_polynomial_kernel.py |  27 +-
 ...jastrow_factor_electron_electron_nuclei.py |  46 ++-
 .../kernels/boys_handy_jastrow_kernel.py      |   9 +-
 .../kernels/fully_connected_jastrow_kernel.py |   4 +-
 ...ow_kernel_electron_electron_nuclei_base.py |   8 +-
 .../jastrow_factor_electron_nuclei.py         |  38 +-
 .../kernels/fully_connected_jastrow_kernel.py |   7 +-
 .../jastrow_kernel_electron_nuclei_base.py    |  13 +-
 .../kernels/pade_jastrow_kernel.py            |  10 +-
 .../wavefunction/jastrows/graph/__init__.py   |   2 +-
 .../jastrows/graph/elec_elec_graph.py         |   2 +-
 .../jastrows/graph/elec_nuc_graph.py          |   8 +-
 .../jastrows/graph/mgcn_jastrow.py            |  28 +-
 .../wavefunction/orbitals/atomic_orbitals.py  |  77 ++--
 .../orbitals/atomic_orbitals_backflow.py      |  53 +--
 .../backflow/backflow_transformation.py       |  14 +-
 .../orbitals/backflow/kernels/__init__.py     |   2 +-
 .../backflow_kernel_autodiff_inverse.py       |   3 +-
 .../backflow/kernels/backflow_kernel_base.py  |  15 +-
 .../backflow/kernels/backflow_kernel_exp.py   |  11 +-
 .../backflow_kernel_fully_connected.py        |   3 +-
 .../kernels/backflow_kernel_power_sum.py      |   1 +
 .../backflow/kernels/backflow_kernel_rbf.py   |  57 ++-
 .../kernels/backflow_kernel_square.py         |   1 +
 .../orbital_dependent_backflow_kernel.py      |  13 +-
 ...bital_dependent_backflow_transformation.py |  13 +-
 .../wavefunction/orbitals/norm_orbital.py     |  64 ++--
 .../wavefunction/orbitals/radial_functions.py |   4 +-
 .../orbitals/spherical_harmonics.py           |  10 +-
 .../pooling/orbital_configurations.py         |  32 +-
 .../wavefunction/pooling/orbital_projector.py |  59 +--
 .../wavefunction/pooling/slater_pooling.py    |  79 ++--
 qmctorch/wavefunction/slater_jastrow.py       | 123 +++---
 .../slater_orbital_dependent_jastrow.py       |  26 +-
 qmctorch/wavefunction/wf_base.py              |  27 +-
 setup.py                                      |  82 ++--
 tests/ase/test_ase_calc.py                    |  39 +-
 tests/solver/test_base_solver.py              |  15 +-
 .../test_generic_jastrow_orbital.py           |  53 ++-
 .../elec_elec/test_generic_jastrow.py         |   8 +-
 .../jastrows/elec_elec/test_pade_jastrow.py   |   8 +-
 .../elec_elec/test_pade_jastrow_polynom.py    |   8 +-
 .../elec_elec/test_scaled_pade_jastrow.py     |   8 +-
 .../test_scaled_pade_jastrow_polynom.py       |   8 +-
 .../test_three_body_jastrow_boys_handy.py     |   8 +-
 ...test_three_body_jastrow_fully_connected.py |   8 +-
 .../test_electron_nuclei_fully_connected.py   |   8 +-
 .../test_electron_nuclei_pade_jastrow.py      |   8 +-
 .../orbitals/backflow/test_backflow_base.py   |  23 +-
 .../test_backflow_kernel_exp_pyscf.py         |   6 +-
 .../test_backflow_kernel_generic_pyscf.py     |   5 +-
 .../test_backflow_kernel_inverse_pyscf.py     |   7 +-
 .../test_backflow_transformation_pyscf.py     |   4 +-
 .../test_backflow_transformation_rbf_pyscf.py |   3 +-
 ...dependent_backflow_transformation_pyscf.py |   5 +-
 .../orbitals/test_ao_derivatives_adf.py       |   1 +
 .../test_backflow_ao_derivatives_pyscf.py     |   1 +
 ...dependent_backflow_ao_derivatives_pyscf.py |   1 +
 .../test_compare_slaterjastrow_backflow.py    |   2 +
 ...laterjastrow_orbital_dependent_backflow.py |   1 +
 .../test_slater_orbital_dependent_jastrow.py  |   6 +-
 .../test_slatercombinedjastrow_backflow.py    |   1 +
 .../test_slaterjastrow_backflow.py            |   1 +
 ...laterjastrow_orbital_dependent_backflow.py |   1 +
 tests_hvd/test_h2_hvd.py                      |  55 +--
 112 files changed, 1582 insertions(+), 1175 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 96a423a5..1499e898 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -59,32 +59,33 @@
 
 
 autodoc_mock_imports = [
-    'numpy',
-    'scipy',
-    'h5py',
-    'twiggy',
-    'mpi4py',
-    'scipy.signal',
-    'torch',
-    'torch.utils',
-    'torch.utils.data',
-    'matplotlib',
-    'matplotlib.pyplot',
-    'torch.autograd',
-    'torch.nn',
-    'torch.optim',
-    'torch.cuda',
-    'torch.distributions',
-    'mendeleev',
-    'pandas',
-    'pyscf',
-    'adf',
-    'scm',
-    'tqdm',
-    'ase',
-    'horovod']
-
-sys.path.insert(0, os.path.abspath('../'))
+    "numpy",
+    "scipy",
+    "h5py",
+    "twiggy",
+    "mpi4py",
+    "scipy.signal",
+    "torch",
+    "torch.utils",
+    "torch.utils.data",
+    "matplotlib",
+    "matplotlib.pyplot",
+    "torch.autograd",
+    "torch.nn",
+    "torch.optim",
+    "torch.cuda",
+    "torch.distributions",
+    "mendeleev",
+    "pandas",
+    "pyscf",
+    "adf",
+    "scm",
+    "tqdm",
+    "ase",
+    "horovod",
+]
+
+sys.path.insert(0, os.path.abspath("../"))
 
 
 # -- General configuration ------------------------------------------------
@@ -97,58 +98,58 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'sphinx.ext.intersphinx',
-    'sphinx.ext.todo',
-    'sphinx.ext.coverage',
-    'sphinx.ext.mathjax',
-    'sphinx.ext.ifconfig',
-    'sphinx.ext.napoleon',
-    'sphinx.ext.viewcode',
-    'nbsphinx'
+    "sphinx.ext.autodoc",
+    "sphinx.ext.doctest",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.todo",
+    "sphinx.ext.coverage",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "nbsphinx",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = 'QMCTorch'
-copyright = '2020, Nicolas Renaud'
-author = 'Nicolas Renaud'
+project = "QMCTorch"
+copyright = "2020, Nicolas Renaud"
+author = "Nicolas Renaud"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '0.1'
+version = "0.1"
 # The full version, including alpha/beta/rc tags.
-release = '0.1.0'
+release = "0.1.0"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = 'en'
+language = "en"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -165,7 +166,7 @@
 # else:
 #     html_theme = 'classic'
 
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 html_logo = "./pics/qmctorch_white.png"
 
 # Theme options are theme-specific and customize the look and feel of a theme
@@ -180,7 +181,7 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -188,11 +189,11 @@
 # This is required for the alabaster theme
 # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
 html_sidebars = {
-    '**': [
-        'globaltoc.html',
-        'relations.html',  # needs 'show_related': True theme option to display
-        'sourcelink.html',
-        'searchbox.html',
+    "**": [
+        "globaltoc.html",
+        "relations.html",  # needs 'show_related': True theme option to display
+        "sourcelink.html",
+        "searchbox.html",
     ]
 }
 
@@ -200,7 +201,7 @@
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'QMCTorchdoc'
+htmlhelp_basename = "QMCTorchdoc"
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -209,15 +210,12 @@
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
-
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -227,8 +225,7 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'QMCTorch.tex', 'QMCTorch Documentation',
-     'Nicolas Renaud', 'manual'),
+    (master_doc, "QMCTorch.tex", "QMCTorch Documentation", "Nicolas Renaud", "manual"),
 ]
 
 
@@ -236,10 +233,7 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'qmctorch', 'QMCTorch Documentation',
-     [author], 1)
-]
+man_pages = [(master_doc, "qmctorch", "QMCTorch Documentation", [author], 1)]
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -248,19 +242,25 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'QMCTorch', 'QMCTorch Documentation',
-     author, 'QMCTorch', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "QMCTorch",
+        "QMCTorch Documentation",
+        author,
+        "QMCTorch",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
 
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {
-    'python': ('https://docs.python.org/', None),
-    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
-    'pytorch': ('http://pytorch.org/docs/1.4.0/', None),
+    "python": ("https://docs.python.org/", None),
+    "numpy": ("http://docs.scipy.org/doc/numpy/", None),
+    "pytorch": ("http://pytorch.org/docs/1.4.0/", None),
 }
 
-autoclass_content = 'init'
-autodoc_member_order = 'bysource'
+autoclass_content = "init"
+autodoc_member_order = "bysource"
 nbsphinx_allow_errors = True
-nbsphinx_execute = 'never'
\ No newline at end of file
+nbsphinx_execute = "never"
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index b367b48c..7032544b 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,6 +1,6 @@
-from qmctorch.ase import QMCTorch     
+from qmctorch.ase import QMCTorch
 from qmctorch.ase.optimizer import TorchOptimizer
-from ase import Atoms 
+from ase import Atoms
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
 import torch
@@ -11,24 +11,24 @@
 np.random.seed(0)
 
 d = 0.70
-h2 = Atoms('H2', positions=[(0, 0, -d/2), (0, 0, d/2)])
+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'
+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,2)'
+h2.calc.wf_options.configs = "single_double(2,2)"
 h2.calc.wf_options.orthogonalize_mo = False
 # h2.calc.wf_options.gto2sto = True
-h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
+h2.calc.wf_options.jastrow.kernel_kwargs = {"w": 1.0}
 
 # sampler options
 h2.calc.sampler_options.nwalkers = 100
-h2.calc.sampler_options.nstep  = 5000
+h2.calc.sampler_options.nstep = 5000
 h2.calc.sampler_options.step_size = 0.5
 h2.calc.sampler_options.ntherm = 4000
 h2.calc.sampler_options.ndecor = 10
@@ -37,10 +37,10 @@
 h2.calc.solver_options.freeze = []
 h2.calc.solver_options.niter = 10
 h2.calc.solver_options.tqdm = True
-h2.calc.solver_options.grad = 'manual'
+h2.calc.solver_options.grad = "manual"
 
 # options for the resampling
-h2.calc.solver_options.resampling.mode = 'update'
+h2.calc.solver_options.resampling.mode = "update"
 h2.calc.solver_options.resampling.resample_every = 1
 h2.calc.solver_options.resampling.ntherm_update = 100
 
@@ -48,11 +48,11 @@
 h2.calc.initialize()
 
 # use torch optim for the optimization
-# dyn = TorchOptimizer(h2, 
-#                      trajectory='traj.xyz', 
-#                      nepoch_wf_init=50, 
-#                      nepoch_wf_update=15, 
+# dyn = TorchOptimizer(h2,
+#                      trajectory='traj.xyz',
+#                      nepoch_wf_init=50,
+#                      nepoch_wf_update=15,
 #                      tqdm=True)
-dyn = FIRE(h2, trajectory='traj.xyz')
+dyn = FIRE(h2, trajectory="traj.xyz")
 dyn.run(fmax=0.005, steps=5)
-write('final.xyz',h2)
+write("final.xyz", h2)
diff --git a/docs/example/ase/h2_cc.py b/docs/example/ase/h2_cc.py
index c0011484..0cb59712 100644
--- a/docs/example/ase/h2_cc.py
+++ b/docs/example/ase/h2_cc.py
@@ -1,16 +1,16 @@
 from pyscf import gto, scf, cc
 import numpy as np
-import matplotlib.pyplot as plt 
+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)
+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)    
+    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
+plt.show()
diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index 6d0e17dd..f5e601f2 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -4,26 +4,26 @@
 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.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')
+    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)')
+wf = SlaterJastrow(mol, kinetic="auto", jastrow=jastrow, configs="single(2,2)")
 
 # sampler
 sampler = Metropolis(
@@ -34,10 +34,9 @@
     step_size=0.5,
     ndim=wf.ndim,
     nelec=wf.nelec,
-    init=mol.domain('normal'),
-    move={
-        'type': 'all-elec',
-        'proba': 'normal'})
+    init=mol.domain("normal"),
+    move={"type": "all-elec", "proba": "normal"},
+)
 
 opt = optim.Adam(wf.parameters(), lr=0.01)
 
@@ -47,7 +46,6 @@
 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"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 d557ef25..48a8144b 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -13,7 +13,6 @@
 
 
 class MyBackflow(BackFlowKernelBase):
-
     def __init__(self, mol, cuda, size=16):
         super().__init__(mol, cuda)
         self.fc1 = nn.Linear(1, size, bias=False)
@@ -27,20 +26,28 @@ def _backflow_kernel(self, x):
 
 
 # define the molecule
-mol = Molecule(atom='Li 0. 0. 0.; H 3.14 0. 0.', unit='angs',
-               calculator='pyscf', basis='sto-3g', name='LiH')
+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})
+backflow = BackFlowTransformation(mol, MyBackflow, {"size": 64})
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic='jacobi',
-                   jastrow=jastrow,
-                   backflow=backflow,
-                   configs='single_double(2,2)')
-
-pos = torch.rand(10, wf.nelec*3)
+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 755441ff..fcbaf1ef 100644
--- a/docs/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -6,7 +6,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
+from qmctorch.utils import plot_energy, plot_data
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -16,58 +16,65 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-               calculator='adf',
-               basis='dzp',
-               unit='bohr')
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator="adf", 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)
+wf = SlaterJastrow(
+    mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=True
+)
 
 # sampler
-sampler = Metropolis(nwalkers=2000,
-                     nstep=2000, step_size=0.2,
-                     ntherm=-1, ndecor=100,
-                     nelec=wf.nelec, init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'},
-                     cuda=True)
+sampler = Metropolis(
+    nwalkers=2000,
+    nstep=2000,
+    step_size=0.2,
+    ntherm=-1,
+    ndecor=100,
+    nelec=wf.nelec,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+    cuda=True,
+)
 
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
-           {'params': wf.ao.parameters(), 'lr': 1E-6},
-           {'params': wf.mo.parameters(), 'lr': 1E-3},
-           {'params': wf.fc.parameters(), 'lr': 2E-3}]
-opt = optim.Adam(lr_dict, lr=1E-3)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 3e-3},
+    {"params": wf.ao.parameters(), "lr": 1e-6},
+    {"params": wf.mo.parameters(), "lr": 1e-3},
+    {"params": wf.fc.parameters(), "lr": 2e-3},
+]
+opt = optim.Adam(lr_dict, lr=1e-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # 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()
 
 # optimize the wave function
 # configure the solver
-solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                 loss='energy', grad='auto',
-                 ortho_mo=False, clip_loss=False,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 50})
+solver.configure(
+    track=["local_energy"],
+    freeze=["ao", "mo"],
+    loss="energy",
+    grad="auto",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+)
 
 # optimize the wave function
 obs = solver.run(250)
 
 plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname='jastrow.weight')
+plot_data(solver.observable, obsname="jastrow.weight")
diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
index dd526405..caed28ec 100644
--- a/docs/example/graph/h2.py
+++ b/docs/example/graph/h2.py
@@ -7,11 +7,13 @@
 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')
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator="pyscf", basis="dzp", unit="bohr"
+)
 
 # jastrow
 jastrow = JastrowFactor(mol, PadeJastrowKernel)
@@ -19,38 +21,60 @@
 
 # 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},
-        )
+    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()
+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'))
+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)
+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}
-                 )
+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
diff --git a/docs/example/graph/jast_graph.py b/docs/example/graph/jast_graph.py
index d294fd0a..0fee14d4 100644
--- a/docs/example/graph/jast_graph.py
+++ b/docs/example/graph/jast_graph.py
@@ -1,8 +1,8 @@
-
 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
 
@@ -19,10 +19,10 @@
 )
 
 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},
-        )
+    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)
diff --git a/docs/example/horovod/h2.py b/docs/example/horovod/h2.py
index 4e4b76f3..7ce8207b 100644
--- a/docs/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import SolverMPI
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import (plot_energy, plot_data)
+from qmctorch.utils import plot_energy, plot_data
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -22,51 +22,64 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', unit='bohr',
-               calculator='pyscf', basis='sto-3g',
-               rank=hvd.local_rank(), mpi_size=hvd.local_size())
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69",
+    unit="bohr",
+    calculator="pyscf",
+    basis="sto-3g",
+    rank=hvd.local_rank(),
+    mpi_size=hvd.local_size(),
+)
 
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic='jacobi',
-                   configs='cas(2,2)',
-                   cuda=use_cuda)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="cas(2,2)", cuda=use_cuda)
 
 # sampler
-sampler = Metropolis(nwalkers=200,
-                     nstep=200, step_size=0.2,
-                     ntherm=-1, ndecor=100,
-                     nelec=wf.nelec, init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'},
-                     cuda=use_cuda)
+sampler = Metropolis(
+    nwalkers=200,
+    nstep=200,
+    step_size=0.2,
+    ntherm=-1,
+    ndecor=100,
+    nelec=wf.nelec,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+    cuda=use_cuda,
+)
 
 
 # optimizer
-lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
-           {'params': wf.ao.parameters(), 'lr': 1E-6},
-           {'params': wf.mo.parameters(), 'lr': 1E-3},
-           {'params': wf.fc.parameters(), 'lr': 2E-3}]
-opt = optim.Adam(lr_dict, lr=1E-3)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 3e-3},
+    {"params": wf.ao.parameters(), "lr": 1e-6},
+    {"params": wf.mo.parameters(), "lr": 1e-3},
+    {"params": wf.fc.parameters(), "lr": 2e-3},
+]
+opt = optim.Adam(lr_dict, lr=1e-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverMPI(wf=wf, sampler=sampler,
-                                    optimizer=opt, scheduler=scheduler,
-                                    rank=hvd.rank())
+solver = SolverMPI(
+    wf=wf, sampler=sampler, optimizer=opt, scheduler=scheduler, rank=hvd.rank()
+)
 
 # configure the solver
-solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                 loss='energy', grad='auto',
-                 ortho_mo=False, clip_loss=False,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 50})
+solver.configure(
+    track=["local_energy"],
+    freeze=["ao", "mo"],
+    loss="energy",
+    grad="auto",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+)
 
 # optimize the wave function
 obs = solver.run(250)
 
 if hvd.rank() == 0:
     plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-    plot_data(solver.observable, obsname='jastrow.weight')
+    plot_data(solver.observable, obsname="jastrow.weight")
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 70f6fd28..41354569 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils.plot_data import (plot_energy, plot_data)
+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
 
@@ -21,18 +21,15 @@
 np.random.seed(0)
 
 # define the molecule
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-               calculator='pyscf',
-               basis='sto-3g',
-               unit='bohr')
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69", calculator="pyscf", 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=jastrow)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="single_double(2,2)", jastrow=jastrow)
 
 # sampler
 # sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
@@ -40,16 +37,24 @@
 #                       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'))
+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},
-           {'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)
+lr_dict = [
+    {"params": wf.jastrow.parameters(), "lr": 1e-2},
+    {"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)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
@@ -61,14 +66,20 @@
 # 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,
-                 resampling={'mode': 'update',
-                             'resample_every': 1,
-                             'nstep_update': 150,
-                             'ntherm_update': 50}
-                 )
+solver.configure(
+    track=["local_energy", "parameters"],
+    freeze=["ao"],
+    loss="energy",
+    grad="manual",
+    ortho_mo=False,
+    clip_loss=False,
+    resampling={
+        "mode": "update",
+        "resample_every": 1,
+        "nstep_update": 150,
+        "ntherm_update": 50,
+    },
+)
 
 # optimize the wave function
 obs = solver.run(5)  # , batchsize=10)
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index bba8df9f..e7a263b8 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -1,24 +1,16 @@
 from qmctorch.scf import Molecule
 
 # Select the SCF calculator
-calc = ['pyscf',            # pyscf  
-        'adf',              # adf 2020+ 
-        'adf2019'           # adf 2019
-    ][1]
+calc = ["pyscf", "adf", "adf2019"][1]  # pyscf  # adf 2020+  # adf 2019
 
 # select an appropriate basis
-basis = {
-    'pyscf'  : 'sto-6g',
-    'adf'    : 'VB1',
-    'adf2019': 'dz'
-}[calc]
+basis = {"pyscf": "sto-6g", "adf": "VB1", "adf2019": "dz"}[calc]
 
 # do the scf calculation
-mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
-            calculator=calc,
-            basis=basis,
-            unit='bohr',
-            redo_scf=True)
-
-
-
+mol = Molecule(
+    atom="H 0 0 -0.69; H 0 0 0.69",
+    calculator=calc,
+    basis=basis,
+    unit="bohr",
+    redo_scf=True,
+)
diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
index 3a1c603c..c443af8a 100644
--- a/docs/example/single_point/h2.py
+++ b/docs/example/single_point/h2.py
@@ -4,25 +4,33 @@
 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')
+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()
+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)
+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)
diff --git a/docs/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
index 507a78cb..d07b3086 100644
--- a/docs/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -7,22 +7,31 @@
 
 
 # define the molecule
-mol = Molecule(atom='water.xyz', unit='angs',
-               calculator='pyscf', basis='sto-3g' , 
-               name='water', redo_scf=True)
+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', jastrow=jastrow)
+wf = SlaterJastrow(mol, kinetic="jacobi", configs="ground_state", jastrow=jastrow)
 
 # sampler
-sampler = Metropolis(nwalkers=1000, nstep=500, step_size=0.25,
-                     nelec=wf.nelec, ndim=wf.ndim,
-                     init=mol.domain('atomic'),
-                     move={'type': 'all-elec', 'proba': 'normal'})
+sampler = Metropolis(
+    nwalkers=1000,
+    nstep=500,
+    step_size=0.25,
+    nelec=wf.nelec,
+    ndim=wf.ndim,
+    init=mol.domain("atomic"),
+    move={"type": "all-elec", "proba": "normal"},
+)
 
 # solver
 solver = Solver(wf=wf, sampler=sampler)
@@ -37,4 +46,4 @@
 # compute the sampling traj
 pos = solver.sampler(solver.wf.pdf)
 obs = solver.sampling_traj(pos)
-plot_walkers_traj(obs.local_energy, walkers='mean')
+plot_walkers_traj(obs.local_energy, walkers="mean")
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 5c572f82..9a1e941d 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,7 +1,11 @@
-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
+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" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index 5ebd7d19..f9aa3e11 100644
--- a/qmctorch/__version__.py
+++ b/qmctorch/__version__.py
@@ -1 +1 @@
-__version__ = "0.3.2"
\ No newline at end of file
+__version__ = "0.3.2"
diff --git a/qmctorch/ase/__init__.py b/qmctorch/ase/__init__.py
index 3ac3ba05..cf90b586 100644
--- a/qmctorch/ase/__init__.py
+++ b/qmctorch/ase/__init__.py
@@ -1 +1 @@
-from .ase import QMCTorch 
\ No newline at end of file
+from .ase import QMCTorch
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index cf7f72eb..5ff3f0bd 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -9,21 +9,26 @@
 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 ..wavefunction.orbitals.backflow import (
+    BackFlowTransformation,
+    BackFlowKernelInverse,
+)
 from ..solver import Solver
 from ..sampler import Metropolis
 from .. import log
 
-class QMCTorch(Calculator):
 
+class QMCTorch(Calculator):
     implemented_properties = ["energy", "forces"]
 
-    def __init__(self,
-                 restart: str = None,
-                 *,
-                 labels: list = None,
-                 atoms: Atoms = None,
-                 **kwargs: dict) -> None:
+    def __init__(
+        self,
+        restart: str = None,
+        *,
+        labels: list = None,
+        atoms: Atoms = None,
+        **kwargs: dict
+    ) -> None:
         """
         Initialize a QMCTorchCalculator object.
 
@@ -52,58 +57,69 @@ def __init__(self,
 
         # default options for the SCF
         self.molecule = None
-        self.scf_options = SimpleNamespace(calculator='pyscf',
-                                           basis='dzp',
-                                           scf='hf')
+        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,
-                                          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.wf_options = SimpleNamespace(
+            kinetic="jacobi",
+            configs="single_double(2,2)",
+            orthogonalize_mo=True,
+            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.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)
+        self.sampler_options = SimpleNamespace(
+            nwalkers=4000, nstep=2000, ntherm=-1, ndecor=1, step_size=0.05
+        )
         self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
-        
-        # optimizer .... 
+
+        # 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.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())
-        
+        self.recognized_resampling_options = list(
+            self.solver_options.resampling.__dict__.keys()
+        )
+
     @staticmethod
-    def validate_options(options: SimpleNamespace, recognized_options: list, name: str = "") -> None:
+    def validate_options(
+        options: SimpleNamespace, recognized_options: list, name: str = ""
+    ) -> None:
         """
         Validate that the options provided are valid.
 
@@ -128,7 +144,8 @@ def validate_options(options: SimpleNamespace, recognized_options: list, name: s
         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)
+                    "Invalid %s options: %s. Recognized options are %s"
+                    % (name, opt, recognized_options)
                 )
 
     def run_scf(self) -> None:
@@ -148,17 +165,20 @@ def run_scf(self) -> None:
         -------
         None
         """
-        self.validate_options(self.scf_options, self.recognized_scf_options, 'SCF')
+        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)
+        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:
         """
@@ -175,37 +195,51 @@ def set_wf(self) -> None:
         # 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)
+            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)
+            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,
-                                orthogonalize_mo=self.wf_options.orthogonalize_mo,
-                                include_all_mo=self.wf_options.include_all_mo,
-                                cuda=self.use_cuda)
-        
+        # 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,
+            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':
+            if self.scf_options.calculator != "pyscf":
                 raise ValueError("gto2sto is only supported for pyscf")
             self.wf = self.wf.gto2sto()
 
@@ -226,44 +260,60 @@ def set_sampler(self) -> None:
         """
         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'), cuda=self.use_cuda)
-        
+        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"),
+            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)
-
+        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 
+        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 
+        - 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` 
+        - 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'):
+        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
+            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'):
+        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
 
@@ -292,24 +342,36 @@ def initialize(self) -> None:
 
         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.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__
-                )
+        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:
         """
@@ -322,7 +384,6 @@ def set_atoms(self, atoms: Atoms) -> None:
         """
         self.atoms = atoms
 
-
     def reset(self) -> None:
         """
         Reset the internal state of the QMCTorchCalculator.
@@ -346,8 +407,8 @@ 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 
+        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 = {}
@@ -377,7 +438,10 @@ def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
         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)):
+            if not np.allclose(
+                self.atoms.get_positions() * ANGS2BOHR,
+                np.array(self.molecule.atom_coords),
+            ):
                 self.reset()
                 self.set_atoms(atoms)
                 self.initialize()
@@ -385,23 +449,27 @@ def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
             if self.solver is None:
                 self.initialize()
 
-    def calculate(self, atoms: Atoms = None, properties: 
-                  list = ['energy'], system_changes: any = None) -> float:
+    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 
+        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 
+            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' 
+            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.
@@ -418,7 +486,7 @@ def calculate(self, atoms: Atoms = None, properties:
 
         Notes
         -----
-        The method first resets the solver if needed, checks the validity of the 
+        The method first resets the solver if needed, checks the validity of the
         requested properties, and then computes each property one-by-one.
         """
 
@@ -427,25 +495,25 @@ def calculate(self, atoms: Atoms = None, properties:
 
         # check properties that are needed
         if any([p not in self.implemented_properties for p in properties]):
-            raise ValueError('property not recognized')
-        
+            raise ValueError("property not recognized")
+
         # compute
         for p in properties:
-            if p == 'forces':
+            if p == "forces":
                 return self._calculate_forces(atoms=atoms)
 
-            elif p == 'energy':
+            elif p == "energy":
                 return self._calculate_energy(atoms=atoms)
 
-    def _calculate_energy(self, atoms: Atoms =None) -> float:
-        # check if reset is necessary 
+    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 
+            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
@@ -466,15 +534,14 @@ def _calculate_energy(self, atoms: Atoms =None) -> float:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
             self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
 
-        # compute the energy 
+        # compute the energy
         observable = self.solver.single_point()
 
         # store and output
-        self.results['energy'] = observable.energy
-        return self.results['energy']
+        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.
@@ -482,7 +549,7 @@ def _calculate_forces(self, atoms: Atoms = None) -> float:
         Parameters
         ----------
         atoms : ASE Atoms object, optional
-            The atoms object to be used for the computation. If not provided, the calculator 
+            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
@@ -503,19 +570,19 @@ def _calculate_forces(self, atoms: Atoms = None) -> float:
         # resample
         observable = self.solver.single_point()
 
-        # compute the forces 
+        # compute the forces
         # we use evaluate_grad_auto as evaluate_grad_manual is not
-        # valid for forces  
+        # valid for forces
         self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
         _, _ = self.solver.evaluate_grad_auto(observable.pos)
 
         # store and output
-        self.results['energy'] = observable.energy.cpu().numpy()
-        self.results['forces'] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.results["energy"] = observable.energy.cpu().numpy()
+        self.results["forces"] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
         self.solver.wf.zero_grad()
 
         self.has_forces = True
-        return self.results['forces']
+        return self.results["forces"]
 
     def check_forces(self) -> bool:
         """
@@ -526,11 +593,11 @@ def check_forces(self) -> bool:
         bool
             True if the forces have been computed, False otherwise.
         """
-        if (self.has_forces) and ('forces' in self.results):
+        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.
@@ -545,14 +612,14 @@ def get_forces(self, atoms: Atoms = None) -> np.ndarray:
         forces : array
             The total forces on the atoms.
         """
-        
+
         self.reset_solver(atoms=atoms)
         if self.check_forces():
-            return self.results['forces']
+            return self.results["forces"]
         else:
             return self._calculate_forces(atoms=atoms)
-    
-    def get_total_energy(self, atoms: Atoms=None) -> float:
+
+    def get_total_energy(self, atoms: Atoms = None) -> float:
         """
         Return the total energy.
 
@@ -567,7 +634,7 @@ def get_total_energy(self, atoms: Atoms=None) -> float:
             The total energy of the system.
         """
         self.reset_solver(atoms=atoms)
-        if 'energy' in self.results:
-            return self.results['energy']
+        if "energy" in self.results:
+            return self.results["energy"]
         else:
-            return self._calculate_energy(atoms=atoms)
\ No newline at end of file
+            return self._calculate_energy(atoms=atoms)
diff --git a/qmctorch/ase/optimizer/__init__.py b/qmctorch/ase/optimizer/__init__.py
index fc36af9c..f05c1bc9 100644
--- a/qmctorch/ase/optimizer/__init__.py
+++ b/qmctorch/ase/optimizer/__init__.py
@@ -1 +1 @@
-from .torch_optim import TorchOptimizer
\ No newline at end of file
+from .torch_optim import TorchOptimizer
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index 55456cca..5f3c9fd0 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -9,25 +9,25 @@
 from ase import Atoms
 from ase.optimize.optimize import Optimizer
 from ase.utils import deprecated
-from ...utils.constants import BOHR2ANGS 
+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)
 
-    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
@@ -56,7 +56,7 @@ def log(self, e: float, forces: np.ndarray) -> float:
         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())
+        fmax = sqrt((forces**2).sum(axis=1).max())
         T = time.localtime()
         if self.logfile is not None:
             name = self.__class__.__name__
@@ -70,8 +70,10 @@ def log(self, e: float, forces: np.ndarray) -> float:
             self.logfile.write(msg)
             self.logfile.flush()
         return fmax
-    
-    def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> SimpleNamespace:
+
+    def run(
+        self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt"
+    ) -> SimpleNamespace:
         """
         Run a geometry optimization.
 
@@ -100,7 +102,7 @@ def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> Simp
         solver = self.atoms.calc.solver
 
         if self.opt_geo is None:
-            self.opt_geo = SGD(solver.wf.parameters(), lr=1E-2)
+            self.opt_geo = SGD(solver.wf.parameters(), lr=1e-2)
             self.opt_geo.lpos_needed = False
 
         # save the optimizer used for the wf params
@@ -123,26 +125,30 @@ def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> Simp
         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.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))
+            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)
+            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))
+            self.optimizable.set_positions(
+                solver.wf.geometry(None, convert_to_angs=True)
+            )
             current_fmax = self.log(cumulative_loss, forces)
             self.call_observers()
 
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 50d088c7..7fb42af4 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -43,9 +43,12 @@ def __init__(  # pylint: disable=dangerous-default-value
             self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
         )
 
-    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
-                 pos: Optional[torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    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:
@@ -141,9 +144,7 @@ def move(self, drift: torch.Tensor) -> torch.Tensor:
         # Return reshaped positions
         return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
-    def _move(
-        self, drift: torch.Tensor, index: int
-    ) -> torch.Tensor:
+    def _move(self, drift: torch.Tensor, index: int) -> torch.Tensor:
         """Move a walker.
 
         Args:
@@ -168,7 +169,9 @@ def _move(
             + mv.sample((self.walkers.nwalkers, 1)).squeeze()
         )
 
-    def trans(self, xf: torch.Tensor, xi: torch.Tensor, drifti: torch.Tensor) -> torch.Tensor:
+    def trans(
+        self, xf: torch.Tensor, xi: torch.Tensor, drifti: torch.Tensor
+    ) -> torch.Tensor:
         """Transform the positions
 
         Args:
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 96b9a146..4ddea9f8 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -42,8 +42,9 @@ def __init__(
         self.traj_length = L
 
     @staticmethod
-    def get_grad(func: Callable[[torch.Tensor], torch.Tensor],
-                 inp: torch.Tensor) -> torch.Tensor:
+    def get_grad(
+        func: Callable[[torch.Tensor], torch.Tensor], inp: torch.Tensor
+    ) -> torch.Tensor:
         """get the gradient of the pdf using autograd
 
         Args:
@@ -76,9 +77,12 @@ def log_func(func: Callable[[torch.Tensor], torch.Tensor]):
         """
         return lambda x: -torch.log(func(x))
 
-    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
-                 pos: Optional[torch.Tensor] = None,
-                 with_tqdm: bool = True) -> torch.Tensor:
+    def __call__(
+        self,
+        pdf: Callable[[torch.Tensor], torch.Tensor],
+        pos: Optional[torch.Tensor] = None,
+        with_tqdm: bool = True,
+    ) -> torch.Tensor:
         """Generate walkers following HMC
 
         Generates a series of walkers following the HMC algorithm
@@ -136,11 +140,15 @@ def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
         return torch.cat(pos).requires_grad_()
 
     @staticmethod
-    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]:
+    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:
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index bcb00645..b7a66c29 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -75,8 +75,9 @@ def log_data(self) -> None:
         log.info("  Move proba          : {0}", self.movedict["proba"])
 
     @staticmethod
-    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
-                 ) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(
+        func: Callable[[torch.Tensor], torch.Tensor]
+    ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the log of a function
 
         Args:
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index cc251d55..584c3753 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -65,8 +65,9 @@ def log_data(self) -> None:
         # log.info('  Move type           : {0}', 'all-elec')
 
     @staticmethod
-    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
-                 ) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(
+        func: Callable[[torch.Tensor], torch.Tensor]
+    ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of  a function
 
         Args:
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index bd8cfa0f..befbe65b 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -13,7 +13,7 @@ def __init__(self, pdf: Callable[[torch.Tensor], torch.Tensor], ndim: int) -> No
             pdf: wf.pdf function
             ndim: number of dimensions
         """
-        self.pdf = pdf 
+        self.pdf = pdf
         self.ndim = ndim
 
     def __call__(self, x: numpy.ndarray) -> numpy.ndarray:
@@ -114,7 +114,9 @@ def log_data(self):
         #     '  Sampler             : {0}', self.method.name(None))
 
     @staticmethod
-    def log_func(func: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(
+        func: Callable[[torch.Tensor], torch.Tensor]
+    ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of a function
 
         Args:
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index 508a9290..0c4d6f7e 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -3,7 +3,8 @@
 
 class BaseProposalKernel(object):
     def __call__(self, x):
-        raise NotImplementedError   
+        raise NotImplementedError
+
 
 class DensityVarianceKernel(BaseProposalKernel):
     def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index 9f037ed2..46729b03 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -61,7 +61,9 @@ def __init__(
         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:
+    def __call__(
+        self, pdf: Callable[[torch.Tensor], torch.Tensor], *args, **kwargs
+    ) -> torch.Tensor:
         """
         Evaluate the sampling algorithm.
 
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index 89196d1e..2176dfae 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -41,13 +41,13 @@ def __call__(self, x: torch.Tensor) -> torch.Tensor:
         """
         nwalkers = x.shape[0]
         scale = self.kernel(x)  # shape (nwalkers, nelec*ndim)
-        displacement = self.multiVariate.sample((nwalkers, self.nelec))  # 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:
+    def get_transition_ratio(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
         """
         Compute the transition ratio for the Metropolis-Hastings acceptance probability.
 
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index 5f94a4f3..c72d2d0e 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -63,10 +63,14 @@ def __init__(  # pylint: disable=too-many-arguments
         )
 
         if charge != 0:
-            raise ValueError("ADF calculator does not support charge yet, open an issue in the repo :)")
-        
+            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 :)")
+            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"]
@@ -128,7 +132,7 @@ def finish_plams(self) -> None:
     def get_plams_molecule(self) -> plams.Molecule:
         """Returns a plams molecule object."""
         mol = plams.Molecule()
-        bohr2angs = BOHR2ANGS # the coordinate are always in bohr
+        bohr2angs = BOHR2ANGS  # the coordinate are always in bohr
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(bohr2angs * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
@@ -291,7 +295,7 @@ def get_basis_data(self, kffile: str) -> SimpleNamespace:
         return basis
 
     @staticmethod
-    def read_array(kf: BinaryIO , section: str, name: str) -> np.ndarray:
+    def read_array(kf: BinaryIO, section: str, name: str) -> np.ndarray:
         """read a data from the kf file
 
         Args:
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index c2429a0b..6e22e966 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -60,7 +60,7 @@ def __init__(  # pylint: disable=too-many-arguments
 
         Returns:
             None
-        
+
         Examples:
             >>> from qmctorch.scf import Molecule
             >>> mol = Molecule(atom='H 0 0 0; H 0 0 1', unit='angs',
diff --git a/qmctorch/solver/loss.py b/qmctorch/solver/loss.py
index 856a50e8..8f2276cf 100644
--- a/qmctorch/solver/loss.py
+++ b/qmctorch/solver/loss.py
@@ -3,11 +3,9 @@
 from torch import nn
 from ..wavefunction import WaveFunction
 
+
 class Loss(nn.Module):
-    def __init__(self, 
-                 wf: WaveFunction, 
-                 method: str = "energy", 
-                 clip: bool = False):
+    def __init__(self, wf: WaveFunction, method: str = "energy", clip: bool = False):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -43,18 +41,15 @@ def __init__(self,
         self.weight = {"psi": None, "psi0": None}
 
     def forward(
-        self, 
-        pos: torch.Tensor, 
-        no_grad: bool = False,
-        deactivate_weight: bool = False
+        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 
+            no_grad (bool, optional): Computes the gradient of the loss
                                       (default: {False})
-            deactivate_weight (bool, optional): Deactivates the weight computation 
+            deactivate_weight (bool, optional): Deactivates the weight computation
                                                (default: {False})
 
         Returns:
@@ -142,4 +137,4 @@ def get_sampling_weights(
             return w
 
         else:
-            return torch.tensor(1.0)
\ No newline at end of file
+            return torch.tensor(1.0)
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 6c682c08..2b3b9fba 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -6,11 +6,12 @@
 import torch
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
-from ..utils import  OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
+from ..utils import OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 from .. import log
 from .solver_base import SolverBase
 from .loss import Loss
 
+
 class Solver(SolverBase):
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -101,12 +102,14 @@ def configure(
         # orthogonalization penalty for the MO coeffs
         self.ortho_mo = ortho_mo
         if self.ortho_mo is True:
-            log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
+            log.warning(
+                "Orthogonalization of the MO coeffs is better done in the wave function"
+            )
             self.ortho_loss = OrthoReg()
 
-    def set_params_requires_grad(self, 
-                                 wf_params: Optional[bool] = True, 
-                                 geo_params: Optional[bool] = 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
@@ -177,14 +180,13 @@ def restore_sampling_parameters(self) -> None:
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
-
     def run(
-        self, 
-        nepoch: int, 
-        batchsize : Optional[int] = None, 
-        hdf5_group: Optional[str] = "wf_opt", 
-        chkpt_every: Optional[int] = None, 
-        tqdm: Optional[bool] = False
+        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
 
@@ -213,7 +215,9 @@ def run(
 
         return self.observable
 
-    def prepare_optimization(self, batchsize: int, chkpt_every: int , tqdm: Optional[bool] = False):
+    def prepare_optimization(
+        self, batchsize: int, chkpt_every: int, tqdm: Optional[bool] = False
+    ):
         """Prepare the optimization process
 
         Args:
@@ -256,9 +260,12 @@ def save_data(self, hdf5_group: str):
 
         add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
-    def run_epochs(self, nepoch: int, 
-                   with_tqdm: Optional[bool] = False, 
-                   verbose: Optional[bool] = True) -> float :
+    def run_epochs(
+        self,
+        nepoch: int,
+        with_tqdm: Optional[bool] = False,
+        verbose: Optional[bool] = True,
+    ) -> float:
         """Run a certain number of epochs
 
         Args:
@@ -271,8 +278,8 @@ def run_epochs(self, nepoch: int,
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
         min_loss = 0  # this is set at n=0
-        
-        # the range 
+
+        # the range
         rng = tqdm(
             range(nepoch),
             desc="INFO:QMCTorch|  Optimization",
@@ -281,12 +288,12 @@ def run_epochs(self, nepoch: int,
 
         # loop over the epoch
         for n in rng:
-
             if verbose:
                 tstart = time()
                 log.info("")
                 log.info(
-                    "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
+                    "  epoch %d | %d sampling points"
+                    % (n, len(self.dataloader.dataset))
                 )
 
             # reset the gradients and loss
@@ -339,7 +346,9 @@ def run_epochs(self, nepoch: int,
 
         return cumulative_loss
 
-    def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    def evaluate_grad_auto(
+        self, lpos: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Evaluate the gradient using automatic differentiation
 
         Args:
@@ -361,12 +370,14 @@ def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Te
 
         return loss, eloc
 
-    def evaluate_grad_manual(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    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 
- 
+        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:
@@ -410,11 +421,13 @@ def evaluate_grad_manual(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.
 
         else:
             raise ValueError("Manual gradient only for energy minimization")
-        
-    def evaluate_grad_manual_2(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+
+    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 
+        as it does not include derivative of the hamiltonian
         wrt atomic positions
 
         https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
@@ -447,10 +460,10 @@ def evaluate_grad_manual_2(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torc
             psi = self.wf(lpos)
             norm = 2.0 / len(psi)
 
-            weight1 = norm * eloc/psi.detach().clone()
-            weight2 = -norm * eloc_mean/psi.detach().clone()
+            weight1 = norm * eloc / psi.detach().clone()
+            weight2 = -norm * eloc_mean / psi.detach().clone()
 
-            psi.backward(weight1,retain_graph=True) 
+            psi.backward(weight1, retain_graph=True)
             psi.backward(weight2)
 
             return torch.mean(eloc), eloc
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index d919560d..9cc441d3 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -11,6 +11,7 @@
 from ..utils import add_group_attr, dump_to_hdf5
 from ..utils import get_git_tag
 
+
 class SolverBase:
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -65,7 +66,6 @@ def __init__(  # pylint: disable=too-many-arguments
             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)
@@ -75,8 +75,8 @@ def __init__(  # pylint: disable=too-many-arguments
 
     def configure_resampling(  # pylint: disable=too-many-arguments
         self,
-        mode: str ="update",
-        resample_every: int =1,
+        mode: str = "update",
+        resample_every: int = 1,
         nstep_update: int = 25,
         ntherm_update: int = -1,
         increment: Dict = {"every": None, "factor": None},
@@ -145,7 +145,7 @@ def track_observable(self, obs_name: Union[str, List[str]]):
         # 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"]
@@ -172,10 +172,13 @@ def track_observable(self, obs_name: Union[str, List[str]]):
 
         self.observable.models = SimpleNamespace()
 
-    def store_observable(self, pos: torch.tensor, 
-                         local_energy: Optional[torch.tensor] = None, 
-                         ibatch: Optional[int] = 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:
@@ -267,7 +270,7 @@ def print_observable(self, cumulative_loss: float, verbose: bool = False):
                 )
                 log.options(style="percent").info("loss %f" % (cumulative_loss))
 
-    def resample(self, n : int, pos: torch.tensor) -> torch.tensor:
+    def resample(self, n: int, pos: torch.tensor) -> torch.tensor:
         """Resample the wave function
 
         Args:
@@ -310,9 +313,12 @@ def resample(self, n : int, pos: torch.tensor) -> torch.tensor:
 
         return pos
 
-    def single_point(self, with_tqdm: Optional[bool] = True, 
-                     batchsize: Optional[int] = None, 
-                     hdf5_group: str = "single_point"):
+    def single_point(
+        self,
+        with_tqdm: Optional[bool] = True,
+        batchsize: Optional[int] = None,
+        hdf5_group: str = "single_point",
+    ):
         """Performs a single point calculation
 
         Args:
@@ -380,7 +386,7 @@ def single_point(self, with_tqdm: Optional[bool] = True,
 
         return obs
 
-    def save_checkpoint(self, epoch: int , loss: float):
+    def save_checkpoint(self, epoch: int, loss: float):
         """save the model and optimizer state
 
         Args:
@@ -414,7 +420,7 @@ def load_checkpoint(self, filename: str) -> Tuple[int, float]:
         loss = data["loss"]
         return epoch, loss
 
-    def _append_observable(self, key : str, data: Any):
+    def _append_observable(self, key: str, data: Any):
         """Append a new data point to observable key.
 
         Arguments:
@@ -426,10 +432,12 @@ def _append_observable(self, key : str, data: Any):
             self.obs_dict[key] = []
         self.obs_dict[key].append(data)
 
-    def sampling_traj(self, pos: Optional[torch.tensor] = None, 
-                      with_tqdm: Optional[bool] = True, 
-                      hdf5_group: Optional[str] = "sampling_trajectory"
-                      ) -> torch.tensor:
+    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:
@@ -459,7 +467,7 @@ def sampling_traj(self, pos: Optional[torch.tensor] = None,
         add_group_attr(self.hdf5file, hdf5_group, {"type": "sampling_traj"})
         return obs
 
-    def print_parameters(self, grad: Optional[bool]=False) -> None:
+    def print_parameters(self, grad: Optional[bool] = False) -> None:
         """print parameter values
 
         Args:
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 88d0780d..d2836582 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -22,15 +22,15 @@ def logd(rank: int, *args):
 
 
 class SolverMPI(Solver):
-    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:
+    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:
@@ -208,10 +208,10 @@ def run(  # pylint: disable=too-many-arguments
         return self.observable
 
     def single_point(
-        self, 
-        with_tqdm: bool = True, 
-        batchsize: Optional[int] = None, 
-        hdf5_group: str = "single_point"
+        self,
+        with_tqdm: bool = True,
+        batchsize: Optional[int] = None,
+        hdf5_group: str = "single_point",
     ) -> SimpleNamespace:
         """Performs a single point calculation
 
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index f8d2a5de..6d3df4a1 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -3,6 +3,7 @@
 from typing import List
 from scipy.special import factorial2 as f2
 
+
 def btrace(M: torch.Tensor) -> torch.Tensor:
     """Computes the trace of batched matrices
 
@@ -51,7 +52,7 @@ def double_factorial(input: List) -> np.ndarray:
         List: values of the double factorial
     """
     output = f2(input)
-    return np.array([1 if o==0 else o for o in output])
+    return np.array([1 if o == 0 else o for o in output])
 
 
 class BatchDeterminant(torch.autograd.Function):
diff --git a/qmctorch/utils/constants.py b/qmctorch/utils/constants.py
index ff8745e0..a7ff07d8 100644
--- a/qmctorch/utils/constants.py
+++ b/qmctorch/utils/constants.py
@@ -1,2 +1,2 @@
 ANGS2BOHR = 1.8897259886
-BOHR2ANGS = 0.529177
\ No newline at end of file
+BOHR2ANGS = 0.529177
diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index cb7a46a7..eb38cea3 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -6,6 +6,7 @@
 
 from .. import log
 
+
 def print_insert_error(obj, obj_name):
     print(obj_name, obj)
     log.critical(
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index a675e80b..ad40becb 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -60,7 +60,9 @@ def get_mo_max_index(self, orb: str) -> int:
         else:
             raise ValueError("orb must occupied or all")
 
-    def interpolate_mo_irreg_grid(self, pos: torch.Tensor, n: int, orb: str) -> torch.Tensor:
+    def interpolate_mo_irreg_grid(
+        self, pos: torch.Tensor, n: int, orb: str
+    ) -> torch.Tensor:
         """Interpolate the molecular orbitals occupied in the configs.
 
         Args:
@@ -80,13 +82,15 @@ 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()
+                return mo[:, : self.mo_max_index].detach()
 
             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[:, :, : self.mo_max_index] = interpolate_irreg_grid(
+            self.interp_mo_func, pos
+        )
         return mos
 
     def interpolate_mo_reg_grid(
@@ -130,7 +134,9 @@ def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
-    def __call__(self, pos: torch.Tensor, n: int = 6, length: float = 2) -> torch.Tensor:
+    def __call__(
+        self, pos: torch.Tensor, n: int = 6, length: float = 2
+    ) -> torch.Tensor:
         """Interpolate the AO.
 
         Args:
@@ -169,9 +175,7 @@ def __call__(self, pos: torch.Tensor, n: int = 6, length: float = 2) -> torch.Te
 
         return torch.as_tensor(data.transpose(1, 2, 0))
 
-    def get_interpolator(
-        self, n: int = 6, length: float = 2
-    ) -> None:
+    def get_interpolator(self, n: int = 6, length: float = 2) -> None:
         """evaluate the interpolation function.
 
         Args:
@@ -258,9 +262,9 @@ def get_boundaries(
 
 
 def get_reg_grid(
-    atomic_positions: Union[torch.Tensor, np.ndarray, list], 
-    resolution: float = 0.1, 
-    border_length: float = 2.0
+    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
 
@@ -311,8 +315,7 @@ def interpolator_reg_grid(
 
 
 def interpolate_reg_grid(
-    interpfunc: Callable[[np.ndarray], np.ndarray],
-    pos: torch.Tensor
+    interpfunc: Callable[[np.ndarray], np.ndarray], pos: torch.Tensor
 ) -> torch.Tensor:
     """Interpolate the function
 
@@ -395,7 +398,9 @@ def get_log_grid(
     return grid_pts
 
 
-def interpolator_irreg_grid(func: Callable[[np.ndarray], torch.Tensor], grid_pts: np.ndarray) -> Callable:
+def interpolator_irreg_grid(
+    func: Callable[[np.ndarray], torch.Tensor], grid_pts: np.ndarray
+) -> Callable:
     """Compute a linear ND interpolator
 
     Args:
@@ -409,8 +414,7 @@ def interpolator_irreg_grid(func: Callable[[np.ndarray], torch.Tensor], grid_pts
 
 
 def interpolate_irreg_grid(
-    interpfunc: Callable[[np.ndarray], np.ndarray],
-    pos: torch.Tensor
+    interpfunc: Callable[[np.ndarray], np.ndarray], pos: torch.Tensor
 ) -> torch.Tensor:
     """Interpolate the function
 
@@ -423,4 +427,6 @@ def interpolate_irreg_grid(
     """
 
     nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
-    return torch.as_tensor(interpfunc(pos.reshape(nbatch, nelec, ndim).detach().numpy()))
+    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 15222765..6376e36e 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -12,10 +12,10 @@
 
 
 def plot_energy(
-    local_energy: np.ndarray, 
-    e0: Optional[float] = None, 
-    show_variance: bool = False, 
-    clip: bool = False, 
+    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.
@@ -27,6 +27,7 @@ def plot_energy(
         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()
@@ -51,9 +52,7 @@ def clip_values(values: np.ndarray, std_factor: int = 5) -> np.ndarray:
     q25 = np.array([np.quantile(clip_values(e), 0.5 - q) for e in local_energy])
 
     # plot
-    ax.fill_between(
-        epoch, q25, q75, alpha=0.5, color="#4298f4"
-    )
+    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="--")
@@ -72,10 +71,7 @@ def clip_values(values: np.ndarray, std_factor: int = 5) -> np.ndarray:
     plt.show()
 
 
-def plot_data(
-    observable: SimpleNamespace, 
-    obsname: str
-) -> None:
+def plot_data(observable: SimpleNamespace, obsname: str) -> None:
     """Plot the evolution of a given data
 
     Args:
@@ -93,7 +89,9 @@ def plot_data(
     plt.show()
 
 
-def plot_walkers_traj(eloc: np.ndarray, walkers: Union[int, str, None] = "mean") -> None:
+def plot_walkers_traj(
+    eloc: np.ndarray, walkers: Union[int, str, None] = "mean"
+) -> None:
     """Plot the trajectory of all the individual walkers
 
     Args:
@@ -173,10 +171,7 @@ def plot_correlation_coefficient(
 
 
 def plot_integrated_autocorrelation_time(
-    eloc: np.ndarray,
-    rho: np.ndarray = None,
-    size_max: int = 100,
-    C: int = 5
+    eloc: np.ndarray, rho: np.ndarray = None, size_max: int = 100, C: int = 5
 ) -> int:
     """Compute and plot the integrated autocorrelation time.
 
@@ -223,7 +218,9 @@ def plot_integrated_autocorrelation_time(
     return ii
 
 
-def plot_blocking_energy(eloc: np.ndarray, block_size: int, walkers: str = "mean") -> np.ndarray:
+def plot_blocking_energy(
+    eloc: np.ndarray, block_size: int, walkers: str = "mean"
+) -> np.ndarray:
     """Plot the blocked energy values
 
     Args:
diff --git a/qmctorch/utils/provenance.py b/qmctorch/utils/provenance.py
index 9bc8d7ac..b6a4bf1c 100644
--- a/qmctorch/utils/provenance.py
+++ b/qmctorch/utils/provenance.py
@@ -9,13 +9,17 @@ def get_git_tag() -> str:
 
     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")
+        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
+        return __version__ + " - hash commit not found"
diff --git a/qmctorch/utils/stat_utils.py b/qmctorch/utils/stat_utils.py
index e734159d..7afbd1fc 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -3,11 +3,8 @@
 from scipy.signal import fftconvolve
 from typing import Tuple
 
-def blocking(
-    x: np.ndarray,
-    block_size: int,
-    expand: bool = False
-) -> np.ndarray:
+
+def blocking(x: np.ndarray, block_size: int, expand: bool = False) -> np.ndarray:
     """block the data
 
     Args:
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 04a41977..c9cc8d25 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -10,7 +10,7 @@ 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.backends.cudnn.allow_tf32 = False
     # torch.set_default_tensor_type(torch.DoubleTensor)
 
 
@@ -18,15 +18,15 @@ 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.backends.cudnn.allow_tf32 = False
     # torch.set_default_tensor_type(torch.FloatTensor)
 
 
 def fast_power(
-    x: torch.Tensor, 
-    k: torch.Tensor, 
-    mask0: Optional[torch.Tensor] = None, 
-    mask2: Optional[torch.Tensor] = None
+    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.
@@ -78,10 +78,8 @@ def gradients(
 
 
 def diagonal_hessian(
-        out: torch.Tensor, 
-        inp: torch.Tensor, 
-        return_grads: bool = False
-    ) -> torch.Tensor:
+    out: torch.Tensor, inp: torch.Tensor, return_grads: bool = False
+) -> torch.Tensor:
     """Return the diagonal Hessian of `out` with respect to `inp`.
 
     Args:
@@ -148,9 +146,7 @@ def __getitem__(self, index: int) -> torch.Tensor:
 
 class DataLoader:
     def __init__(
-        self, data: torch.Tensor, 
-        batch_size: int, 
-        pin_memory: bool = False
+        self, data: torch.Tensor, batch_size: int, pin_memory: bool = False
     ) -> None:
         """Simple DataLoader to replace torch data loader
 
@@ -200,7 +196,8 @@ def __next__(self) -> torch.Tensor:
             return out
         else:
             raise StopIteration
-        
+
+
 class OrthoReg(nn.Module):
     """add a penalty to make matrice orthgonal."""
 
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index df95a16f..1735eb3d 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -8,12 +8,9 @@
 
 
 class ElectronElectronDistance(nn.Module):
-    def __init__(self, 
-                 nelec: int, 
-                 ndim: int = 3, 
-                 scale: bool = False,
-                 scale_factor: float = 0.6
-                 ) -> None:
+    def __init__(
+        self, nelec: int, ndim: int = 3, scale: bool = False, scale_factor: float = 0.6
+    ) -> None:
         """Computes the electron-electron distances
 
         .. math::
@@ -47,11 +44,7 @@ def __init__(self,
         elif _type_ == torch.float64:
             self.eps = 1e-16
 
-    def forward(
-        self, 
-        input: torch.Tensor, 
-        derivative: int = 0
-    ) -> torch.Tensor:
+    def forward(self, input: torch.Tensor, derivative: int = 0) -> torch.Tensor:
         """Compute the pairwise distance between the electrons
         or its derivative.
 
@@ -66,14 +59,14 @@ def forward(
             \\frac{d r_{ij}}{dx_j} = -\\frac{dr_{ij}}{dx_i}
 
         Args:
-            input (torch.Tensor): position of the electron 
+            input (torch.Tensor): position of the electron
                                   size : Nbatch x [Nelec x Ndim]
-            derivative (int, optional): degre of the derivative. 
+            derivative (int, optional): degre of the derivative.
                                         Defaults to 0.
 
         Returns:
-            torch.Tensor: distance (or derivative) matrix 
-                          Nbatch x Nelec x Nelec if derivative = 0 
+            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
 
         """
@@ -155,7 +148,9 @@ def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tenso
         diff_axis = diff_axis - diff_axis.transpose(2, 3)
         return diff_axis * invr
 
-    def get_second_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
+    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::
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index 20b0cbee..93029b9b 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -113,7 +113,9 @@ def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tenso
         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: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
+    def get_second_der_distance(
+        self, pos: torch.Tensor, dist: torch.Tensor
+    ) -> torch.Tensor:
         """Get the derivative of the electron-nuclei distance matrix
 
         .. math::
@@ -137,7 +139,9 @@ def get_second_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torc
         return diff_axis * invr3
 
     @staticmethod
-    def _get_distance_quadratic(elec_pos: torch.Tensor, atom_pos: torch.Tensor) -> torch.Tensor:
+    def _get_distance_quadratic(
+        elec_pos: torch.Tensor, atom_pos: torch.Tensor
+    ) -> torch.Tensor:
         """Compute the distance following a quadratic expansion
 
         Arguments:
diff --git a/qmctorch/wavefunction/jastrows/distance/scaling.py b/qmctorch/wavefunction/jastrows/distance/scaling.py
index 6c39e1c0..1d20edf6 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -19,7 +19,9 @@ def get_scaled_distance(kappa: float, r: torch.Tensor) -> torch.Tensor:
     return (1.0 - torch.exp(-kappa * r)) / kappa
 
 
-def get_der_scaled_distance(kappa: float, r:torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
+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 +41,9 @@ def get_der_scaled_distance(kappa: float, r:torch.Tensor, dr: torch.Tensor) -> t
     return dr * torch.exp(-kappa * r.unsqueeze(1))
 
 
-def get_second_der_scaled_distance(kappa: float, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+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::
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 e56a850d..e272f6b6 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -3,9 +3,12 @@
 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 .kernels.jastrow_kernel_electron_electron_base import (
+    JastrowKernelElectronElectronBase,
+)
 from ....scf import Molecule
 
+
 class JastrowFactorElectronElectron(nn.Module):
     def __init__(
         self,
@@ -14,9 +17,9 @@ def __init__(
         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,
+        scale: Optional[bool] = False,
+        scale_factor: Optional[float] = 0.6,
+        cuda: Optional[bool] = False,
     ) -> None:
         """Electron-Electron Jastrow factor.
 
@@ -139,11 +142,9 @@ def get_edist_unique(self, pos: torch.Tensor, derivative: int = 0) -> torch.Tens
                 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]]:
+    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:
@@ -194,7 +195,9 @@ def forward(self,
                 self.jastrow_factor_second_derivative(r, dr, d2r, jast),
             )
 
-    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+    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:
@@ -231,7 +234,9 @@ def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: tor
 
         return out
 
-    def jastrow_factor_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor, jast: torch.Tensor) -> torch.Tensor:
+    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:
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 649360a4..87720aac 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
@@ -3,6 +3,7 @@
 from torch.autograd import grad
 from typing import Tuple
 
+
 class JastrowKernelElectronElectronBase(nn.Module):
     def __init__(self, nup: int, ndown: int, cuda: bool, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
@@ -74,7 +75,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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
 
@@ -119,7 +122,9 @@ def _grads(val, pos: torch.Tensor) -> torch.Tensor:
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(val: torch.Tensor, pos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
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 edb1b8f6..707c2d84 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
@@ -116,7 +116,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return a + b
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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
 
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 c61fe142..79ef5b8d 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
@@ -6,8 +6,15 @@
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-    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:
+    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::
@@ -75,7 +82,9 @@ def get_static_weight(self) -> torch.Tensor:
 
         return static_weight
 
-    def set_variational_weights(self, weight_a: Union[torch.Tensor, None], weight_b: Union[torch.Tensor, None]) -> None:
+    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:
@@ -171,7 +180,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return (der_num * denom - num * der_denom) / (denom * denom)
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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
 
@@ -234,7 +245,9 @@ def _compute_polynoms(self, r: torch.Tensor) -> torch.Tensor:
 
         return num, denom
 
-    def _compute_polynom_derivatives(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
+    def _compute_polynom_derivatives(
+        self, r: torch.Tensor, dr: torch.Tensor
+    ) -> torch.Tensor:
         """Computes the derivatives of the polynomials.
 
         Args:
@@ -263,7 +276,9 @@ def _compute_polynom_derivatives(self, r: torch.Tensor, dr: torch.Tensor) -> tor
 
         return der_num, der_denom
 
-    def _compute_polynom_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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:
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 27ca56ba..ab4eb1f8 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
@@ -5,15 +5,19 @@
 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
+from .kernels.jastrow_kernel_electron_electron_nuclei_base import (
+    JastrowKernelElectronElectronNucleiBase,
+)
+
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-    def __init__(self, 
-                 mol: Molecule, 
-                 jastrow_kernel: JastrowKernelElectronElectronNucleiBase, 
-                 kernel_kwargs: Dict = {}, 
-                 cuda: bool = False
-                 ) -> None:
+    def __init__(
+        self,
+        mol: Molecule,
+        jastrow_kernel: JastrowKernelElectronElectronNucleiBase,
+        kernel_kwargs: Dict = {},
+        cuda: bool = False,
+    ) -> None:
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -142,7 +146,9 @@ def assemble_dist(self, pos: torch.Tensor) -> torch.Tensor:
         # cat both
         return torch.cat((ren, ree), -1)
 
-    def assemble_dist_deriv(self, pos: torch.Tensor, derivative: int = 1) -> torch.Tensor:
+    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}]
@@ -179,7 +185,9 @@ def _to_device(self) -> None:
             if at in self.__dict__:
                 self.__dict__[at] = self.__dict__[at].to(self.device)
 
-    def forward(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
+    def forward(
+        self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True
+    ) -> torch.Tensor:
         """Compute the Jastrow factors.
 
         Args:
@@ -244,7 +252,9 @@ def forward(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True)
         else:
             raise ValueError("Derivative value nor recognized")
 
-    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+    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:
@@ -305,12 +315,9 @@ def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: tor
 
         return out
 
-    def jastrow_factor_second_derivative(self, 
-                                         r: torch.Tensor, 
-                                         dr: torch.Tensor, 
-                                         d2r: torch.Tensor, 
-                                         jast: torch.Tensor
-                                         ) -> torch.Tensor:
+    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:
@@ -372,10 +379,9 @@ def partial_derivative(self, djast: torch.Tensor) -> torch.Tensor:
 
         return ((out.sum(2)) ** 2).sum(1)
 
-    def jastrow_factor_second_derivative_auto(self, 
-                                              pos: torch.Tensor, 
-                                              jast: Union[None, torch.Tensor] = None
-                                              ) -> torch.Tensor:
+    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
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 a7bb1c25..7969610a 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
@@ -7,13 +7,8 @@
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
     def __init__(
-        self,
-        nup: int,
-        ndown: int,
-        atomic_pos: torch.Tensor,
-        cuda: bool,
-        nterm: int = 5
-        ) -> None:  # pylint: disable=too-many-arguments
+        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
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 bb4c52b9..e7a015e8 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
@@ -5,7 +5,9 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool)-> None:
+    def __init__(
+        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool
+    ) -> None:
         """Defines a fully connected jastrow factors.
 
         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 3de257e5..c2c316b3 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,7 +5,9 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
-    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs) -> None:
+    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:
@@ -54,7 +56,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         # sum over the atoms
         return out
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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
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 621603b7..e9c46e1d 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -5,13 +5,15 @@
 from ....scf import Molecule
 from .kernels.jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
 
+
 class JastrowFactorElectronNuclei(nn.Module):
-    def __init__(self, 
-                 mol: Molecule, 
-                 jastrow_kernel: JastrowKernelElectronNucleiBase, 
-                 kernel_kwargs: Dict = {}, 
-                 cuda: bool = False
-                 ) -> None:
+    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::
@@ -55,11 +57,12 @@ 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]]:
+    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:
@@ -110,7 +113,9 @@ def forward(self,
                 self.jastrow_factor_second_derivative(r, dr, d2r, jast),
             )
 
-    def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+    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:
@@ -129,12 +134,9 @@ def jastrow_factor_derivative(self, r: torch.Tensor, dr: torch.Tensor, jast: tor
             djast = self.jastrow_kernel.compute_derivative(r, dr).sum(3)
             return djast * jast.unsqueeze(-1)
 
-    def jastrow_factor_second_derivative(self, 
-                                         r: torch.Tensor, 
-                                         dr: torch.Tensor, 
-                                         d2r: torch.Tensor, 
-                                         jast: torch.Tensor
-                                         ) -> torch.Tensor:
+    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:
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 beb06166..8e96ecad 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
@@ -6,12 +6,7 @@
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
     def __init__(
-        self,
-        nup: int,
-        ndown: int,
-        atomic_pos: torch.Tensor,
-        cuda: bool,
-        w: float = 1.0
+        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w: float = 1.0
     ) -> None:
         r"""Computes the Simple Pade-Jastrow factor
 
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 ccd38f54..e0c30a58 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
@@ -3,8 +3,11 @@
 from torch.autograd import grad
 from typing import Tuple
 
+
 class JastrowKernelElectronNucleiBase(nn.Module):
-    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs) -> None:
+    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::
@@ -77,7 +80,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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 +133,9 @@ def _grads(val: torch.Tensor, pos: torch.Tensor) -> torch.Tensor:
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(val: torch.Tensor, pos: torch.Tensor) -> Tuple[torch.Tensor,torch.Tensor]:
+    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
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 b6ca883f..bf909e52 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/kernels/pade_jastrow_kernel.py
@@ -6,7 +6,9 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w: float = 1.0) -> None:
+    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::
@@ -31,7 +33,7 @@ def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w
         self.static_weight = torch.as_tensor([1.0]).to(self.device)
         self.requires_autograd = True
 
-    def forward(self, r:torch.Tensor) -> torch.Tensor:
+    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}}
@@ -76,7 +78,9 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return a + b
 
-    def compute_second_derivative(self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor) -> torch.Tensor:
+    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
 
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index 5b9df08a..1bbde43d 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,3 +1,3 @@
 from .mgcn_jastrow import MGCNJastrowFactor
 
-__all__ = ["MGCNJastrowFactor"]
\ No newline at end of file
+__all__ = ["MGCNJastrowFactor"]
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
index f7d1467f..b462b5d0 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -32,7 +32,7 @@ def get_elec_elec_edges(nelec: int) -> list:
     return ee_edges
 
 
-def get_elec_elec_ndata(nelec:int , nup: int) -> torch.Tensor:
+def get_elec_elec_ndata(nelec: int, nup: int) -> torch.Tensor:
     """Compute the node data of the elec-elec graph"""
 
     ee_ndata = []
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 2d136a54..4efbc921 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -3,7 +3,9 @@
 from mendeleev import element
 
 
-def ElecNucGraph(natoms:int, atom_types:list, atomic_features:list, nelec:int, nup:int) -> dgl.DGLGraph:
+def ElecNucGraph(
+    natoms: int, atom_types: list, atomic_features: list, nelec: int, nup: int
+) -> dgl.DGLGraph:
     """Create the elec-nuc graph
 
     Args:
@@ -39,7 +41,9 @@ def get_elec_nuc_edges(natoms: int, nelec: int) -> tuple:
     return en_edges
 
 
-def get_elec_nuc_ndata(natoms: int, atom_types: list, atomic_features: list, nelec: int, nup: int) -> torch.Tensor:
+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 = []
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
index 40a896b9..f1162109 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -11,6 +11,7 @@
 from .elec_nuc_graph import ElecNucGraph
 from ....scf import Molecule
 
+
 class MGCNJastrowFactor(nn.Module):
     def __init__(
         self,
@@ -83,11 +84,9 @@ 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]]:
+    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:
@@ -147,7 +146,9 @@ def forward(self,
                 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:
+    def _get_val(
+        self, ee_kernel: torch.Tensor, en_kernel: torch.Tensor
+    ) -> torch.Tensor:
         """Get the jastrow values.
 
         Args:
@@ -156,7 +157,13 @@ def _get_val(self, ee_kernel: torch.Tensor, en_kernel: torch.Tensor) -> torch.Te
         """
         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:
+    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
 
 
@@ -180,7 +187,12 @@ def _get_grad_vals(self, pos: torch.Tensor, ee_kernel: torch.Tensor, en_kernel:
         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
+        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
 
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index 1b375c58..ea8428f3 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -11,6 +11,7 @@
 from .spherical_harmonics import Harmonics
 from ...scf import Molecule
 
+
 class AtomicOrbitals(nn.Module):
     def __init__(self, mol: Molecule, cuda: Optional[bool] = False) -> None:
         """Computes the value of atomic orbitals
@@ -128,12 +129,12 @@ def _to_device(self) -> None:
             self.__dict__[at] = self.__dict__[at].to(self.device)
 
     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
+        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.
 
@@ -247,7 +248,9 @@ def _ao_kernel(self, R: torch.Tensor, Y: torch.Tensor) -> torch.Tensor:
             ao = self._contract(ao)
         return ao
 
-    def _compute_first_derivative_ao_values(self, pos: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+    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:
@@ -284,12 +287,9 @@ def _compute_sum_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._sum_gradient_kernel(R, dR, Y, dY)
 
-    def _sum_gradient_kernel(self, 
-                             R: torch.Tensor, 
-                             dR: torch.Tensor, 
-                             Y: torch.Tensor, 
-                             dY: torch.Tensor
-                             ) -> torch.Tensor :
+    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:
@@ -327,12 +327,9 @@ def _compute_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._gradient_kernel(R, dR, Y, dY)
 
-    def _gradient_kernel(self, 
-                         R: torch.Tensor, 
-                         dR: torch.Tensor, 
-                         Y: torch.Tensor, 
-                         dY: torch.Tensor
-                         ) -> torch.Tensor:
+    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:
@@ -358,7 +355,9 @@ def _gradient_kernel(self,
             ao = bas
         return ao
 
-    def _compute_second_derivative_ao_values(self, pos: torch.Tensor, sum_hess: bool) -> torch.Tensor:
+    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:
@@ -395,14 +394,15 @@ def _compute_sum_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor
         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: torch.Tensor, 
-                                 dR: torch.Tensor, 
-                                 d2R: torch.Tensor, 
-                                 Y: torch.Tensor, 
-                                 dY: torch.Tensor, 
-                                 d2Y: torch.Tensor
-                                 ) -> torch.Tensor:
+    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:
@@ -452,14 +452,15 @@ def _compute_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._diag_hessian_kernel(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:
+    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:
@@ -492,7 +493,9 @@ def _diag_hessian_kernel(self,
 
         return d2ao
 
-    def _compute_mixed_second_derivative_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
+    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:
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 2f44fe13..3bf73542 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -4,11 +4,14 @@
 from ...scf import Molecule
 from .backflow.backflow_transformation import BackFlowTransformation
 
+
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
-    def __init__(self, 
-                 mol: Molecule, 
-                 backflow: BackFlowTransformation, 
-                 cuda: Optional[bool] = False) -> None:
+    def __init__(
+        self,
+        mol: Molecule,
+        backflow: BackFlowTransformation,
+        cuda: Optional[bool] = False,
+    ) -> None:
         """Computes the value of atomic orbitals
 
         Args:
@@ -22,12 +25,12 @@ def __init__(self,
         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
+        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.
 
@@ -114,7 +117,9 @@ def forward(
 
         return ao
 
-    def _compute_first_derivative_ao_values(self, pos: torch.Tensor, sum_grad: bool) -> torch.Tensor:
+    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:
@@ -134,10 +139,9 @@ def _compute_first_derivative_ao_values(self, pos: torch.Tensor, sum_grad: bool)
 
         return grad
 
-    def _compute_gradient_backflow_ao_values(self, 
-                                             pos: torch.Tensor, 
-                                             grad_ao: Optional[Union[None, torch.Tensor]] = None
-                                             ) -> torch.Tensor:
+    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:
@@ -173,7 +177,9 @@ def _compute_gradient_backflow_ao_values(self,
 
         return grad_ao
 
-    def _compute_second_derivative_ao_values(self, pos: torch.Tensor, sum_hess: bool) -> torch.Tensor:
+    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:
@@ -194,11 +200,11 @@ def _compute_second_derivative_ao_values(self, pos: torch.Tensor, sum_hess: bool
         return hess
 
     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
+        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
 
@@ -256,8 +262,9 @@ def _compute_diag_hessian_backflow_ao_values(
 
         return hess_ao
 
-    def _compute_all_backflow_ao_values(self, pos: torch.Tensor
-                                        ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor] :
+    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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 291761f8..319ea313 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -43,10 +43,7 @@ def __init__(
         if self.cuda:
             self.device = torch.device("cuda")
 
-    def forward(self, 
-                pos: torch.Tensor, 
-                derivative: Optional[int] = 0
-                ) -> torch.Tensor:
+    def forward(self, pos: torch.Tensor, derivative: Optional[int] = 0) -> torch.Tensor:
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -61,9 +58,7 @@ def forward(self,
                 "derivative of the backflow transformation must be 0, 1 or 2"
             )
 
-    def _get_backflow(self, 
-                      pos: torch.Tensor
-                      ) -> torch.Tensor:
+    def _get_backflow(self, pos: torch.Tensor) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -240,7 +235,7 @@ def _backflow_derivative(self, pos: torch.Tensor) -> torch.Tensor:
 
         return out.unsqueeze(-1)
 
-    def _backflow_derivative_od(self, pos:torch.Tensor) -> torch.Tensor:
+    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
 
@@ -527,7 +522,6 @@ def _backflow_second_derivative_od(self, pos: torch.Tensor) -> torch.Tensor:
 
         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
+        return self.backflow_kernel.__class__.__name__
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
index 249d814d..4b03cf7d 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -15,5 +15,5 @@
     "BackFlowKernelPowerSum",
     "BackFlowKernelSquare",
     "BackFlowKernelRBF",
-    "BackFlowKernelExp"
+    "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 2b5f00e7..7db1ad00 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -3,6 +3,7 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
+
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool, order: int = 2) -> None:
         """Compute the back flow kernel, i.e. the function
@@ -19,7 +20,7 @@ def __init__(self, mol: Molecule, cuda: bool, order: int = 2) -> None:
 
         self.weight = nn.Parameter(torch.as_tensor([1e-3]))
 
-    def _backflow_kernel(self, ree:torch.Tensor) -> torch.Tensor:
+    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_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 5dde3648..22eb6243 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -4,6 +4,7 @@
 from typing import Tuple, List, Union
 from .....scf import Molecule
 
+
 class BackFlowKernelBase(nn.Module):
     def __init__(self, mol: Molecule, cuda: bool):
         """Compute the back flow kernel, i.e. the function
@@ -100,7 +101,9 @@ def _grad(val, ree: torch.Tensor) -> torch.Tensor:
         return grad(val, ree, grad_outputs=torch.ones_like(val), allow_unused=False)[0]
 
     @staticmethod
-    def _hess(val, ree: torch.Tensor) -> Union[torch.Tensor, Tuple[torch.Tensor,torch.Tensor]]:
+    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
@@ -110,9 +113,15 @@ def _hess(val, ree: torch.Tensor) -> Union[torch.Tensor, Tuple[torch.Tensor,torc
             pos ([type]): [description]
         """
 
-        gval = grad(val, ree, grad_outputs=torch.ones_like(val), create_graph=True, allow_unused=False)[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)
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index 94fd9a33..db0e71c0 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -7,7 +7,9 @@
 
 
 class BackFlowKernelExp(BackFlowKernelBase):
-    def __init__(self, mol: Molecule, cuda: bool = False, weight: float = 0.0, alpha : float = 1.0):
+    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
@@ -21,7 +23,7 @@ def __init__(self, mol: Molecule, cuda: bool = False, weight: float = 0.0, alpha
         """
         super().__init__(mol, cuda)
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
-        self.alpha = nn.Parameter(torch.as_tensor([alpha])) 
+        self.alpha = nn.Parameter(torch.as_tensor([alpha]))
 
     def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the backflow kernel:
@@ -55,7 +57,8 @@ def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
 
         # 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)
+        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}
@@ -71,4 +74,4 @@ def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
 
         # 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)
+        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 2dfdc943..0cdc72f2 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_fully_connected.py
@@ -1,7 +1,8 @@
 import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
-from.....scf import Molecule
+from .....scf import Molecule
+
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool):
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 6cd7ab4a..1371671a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -3,6 +3,7 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
+
 class BackFlowKernelPowerSum(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool, order: int = 2):
         """Compute the back flow kernel, i.e. the function
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
index 5887be77..44ae9889 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -6,10 +6,9 @@
 from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
-class BackFlowKernelRBF(BackFlowKernelBase):
 
+class BackFlowKernelRBF(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool = False, num_rbf: int = 10):
-
         """
         Initialize the RBF kernel
 
@@ -45,59 +44,61 @@ def __init__(self, mol: Molecule, cuda: bool = False, num_rbf: int = 10):
         self.sigma.requires_grad = True
 
         self.weight = nn.Parameter(torch.Tensor(num_rbf, 1))
-        self.weight.data.fill_(1.)
+        self.weight.data.fill_(1.0)
         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)
+        self.register_parameter("bias", None)
 
     def _gaussian_kernel(self, ree: torch.Tensor) -> torch.Tensor:
-        
-        '''Compute the RBF kernel
-        
+        """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)
-    
+        """
+        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
-        
+        """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)
-    
+        """
+        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
-        
+        """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
+        return (
+            -2 / self.sigma * kernel
+            - 2 * (ree - self.centers) / self.sigma * derivative
+        )
 
     def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
-        '''Compute the kernel
-        
+        """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)
@@ -105,7 +106,7 @@ def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         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
 
@@ -119,7 +120,7 @@ def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         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
 
@@ -133,5 +134,3 @@ def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         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 2d4a1e01..82974518 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -3,6 +3,7 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
+
 class BackFlowKernelSquare(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool = False):
         """Define a generic kernel to test the auto diff features."""
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index ad5aaf4b..23045abe 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -4,12 +4,15 @@
 from .kernels.backflow_kernel_base import BackFlowKernelBase
 from ....scf import Molecule
 
+
 class OrbitalDependentBackFlowKernel(nn.Module):
-    def __init__(self, 
-                 backflow_kernel: BackFlowKernelBase, 
-                 backflow_kernel_kwargs: Dict, 
-                 mol : Molecule, 
-                 cuda: bool) -> None:
+    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
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index b079c3ff..b89b9612 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -6,12 +6,15 @@
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
 from ....scf import Molecule
 
+
 class OrbitalDependentBackFlowTransformation(nn.Module):
-    def __init__(self, 
-                 mol: Molecule, 
-                 backflow_kernel: BackFlowKernelBase, 
-                 backflow_kernel_kwargs: Dict = {}, 
-                 cuda: bool=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
diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index e251caf3..8d371a8c 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -4,7 +4,8 @@
 from types import SimpleNamespace
 from ...utils.algebra_utils import double_factorial
 
-def atomic_orbital_norm(basis : SimpleNamespace) -> torch.Tensor:
+
+def atomic_orbital_norm(basis: SimpleNamespace) -> torch.Tensor:
     """Computes the norm of the atomic orbitals
 
     Args:
@@ -82,20 +83,22 @@ def norm_gaussian_spherical(bas_n: torch.Tensor, bas_exp: torch.Tensor) -> torch
     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)
-    C = torch.as_tensor(double_factorial(2 * bas_n.int() - 1) * np.pi **
-                        0.5).type(torch.get_default_dtype())
+    A = torch.tensor(bas_exp) ** exp1
+    B = 2 ** (2.0 * bas_n + 3.0 / 2)
+    C = torch.as_tensor(double_factorial(2 * bas_n.int() - 1) * np.pi**0.5).type(
+        torch.get_default_dtype()
+    )
 
     return torch.sqrt(B / C) * A
 
 
-def norm_slater_cartesian(a: torch.Tensor, 
-                          b: torch.Tensor, 
-                          c: torch.Tensor, 
-                          n: torch.Tensor, 
-                          exp: torch.Tensor
-                          ) -> torch.Tensor:
+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
 
@@ -109,7 +112,7 @@ def norm_slater_cartesian(a: torch.Tensor,
     Returns:
         torch.tensor: normalization factor
     """
-    lvals = a + b + c + n + 1.
+    lvals = a + b + c + n + 1.0
 
     lfact = torch.as_tensor([math.factorial(int(2 * i)) for i in lvals]).type(
         torch.get_default_dtype()
@@ -117,23 +120,22 @@ def norm_slater_cartesian(a: torch.Tensor,
 
     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) *
-                          double_factorial(2 * c.astype('int') - 1)
-                          ).type(torch.get_default_dtype())
+    num = torch.as_tensor(
+        double_factorial(2 * a.astype("int") - 1)
+        * double_factorial(2 * b.astype("int") - 1)
+        * double_factorial(2 * c.astype("int") - 1)
+    ).type(torch.get_default_dtype())
 
     denom = torch.as_tensor(
-        double_factorial((2 * a + 2 * b + 2 * c + 1).astype('int')
-           )).type(torch.get_default_dtype())
+        double_factorial((2 * a + 2 * b + 2 * c + 1).astype("int"))
+    ).type(torch.get_default_dtype())
 
     return torch.sqrt(1.0 / (prefact * num / denom))
 
 
-def norm_gaussian_cartesian(a: torch.Tensor, 
-                            b: torch.Tensor, 
-                            c: torch.Tensor, 
-                            exp: torch.Tensor
-                            ) -> torch.Tensor:
+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
 
@@ -146,14 +148,14 @@ def norm_gaussian_cartesian(a: torch.Tensor,
     Returns:
         torch.tensor: normalization factor
     """
-    pref = torch.as_tensor((2 * exp / np.pi)**(0.75))
-    am1 = (2 * a - 1).astype('int')
-    x = (4 * exp)**(a / 2) / torch.sqrt(torch.as_tensor(double_factorial(am1)))
+    pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
+    am1 = (2 * a - 1).astype("int")
+    x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(double_factorial(am1)))
 
-    bm1 = (2 * b - 1).astype('int')
-    y = (4 * exp)**(b / 2) / torch.sqrt(torch.as_tensor(double_factorial(bm1)))
+    bm1 = (2 * b - 1).astype("int")
+    y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(double_factorial(bm1)))
 
-    cm1 = (2 * c - 1).astype('int')
-    z = (4 * exp)**(c / 2) / torch.sqrt(torch.as_tensor(double_factorial(cm1)))
+    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())
\ No newline at end of file
+    return (pref * x * y * z).type(torch.get_default_dtype())
diff --git a/qmctorch/wavefunction/orbitals/radial_functions.py b/qmctorch/wavefunction/orbitals/radial_functions.py
index ed0f39b3..e6df7658 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -245,7 +245,7 @@ def radial_gaussian_pure(
     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
+    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).
 
@@ -327,7 +327,7 @@ def radial_slater_pure(
     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
+    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).
 
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 7b63dab8..0f2b42d4 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -106,7 +106,7 @@ def CartesianHarmonics(
     mask2: torch.Tensor,
     derivative: list = [0],
     sum_grad: bool = True,
-    sum_hess: bool = True
+    sum_hess: bool = True,
 ) -> torch.Tensor:
     r"""Computes Real Cartesian Harmonics
 
@@ -244,7 +244,9 @@ def SphericalHarmonics(
         return get_grad_spherical_harmonics(xyz, l, m)
 
 
-def get_spherical_harmonics(xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor, derivative: int):
+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:
@@ -303,7 +305,9 @@ def get_spherical_harmonics(xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tens
     return Y
 
 
-def get_grad_spherical_harmonics(xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor) -> torch.Tensor:
+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:
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index b6322479..e7c891ec 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -2,6 +2,7 @@
 from typing import Tuple, List
 from ...scf import Molecule
 
+
 class OrbitalConfigurations:
     def __init__(self, mol: Molecule) -> None:
         self.nup = mol.nup
@@ -82,10 +83,9 @@ def _get_ground_state_config(self) -> Tuple[torch.LongTensor, torch.LongTensor]:
         cup, cdown = [_gs_up], [_gs_down]
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_config(self, 
-                           nocc: Tuple[int, int], 
-                           nvirt: Tuple[int, int]
-                           ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -119,10 +119,9 @@ def _get_single_config(self,
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_double_config(self, 
-                           nocc: Tuple[int, int], 
-                           nvirt: Tuple[int, int]
-                           ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -173,11 +172,9 @@ def _get_single_double_config(self,
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_cas_config(self, 
-                        nocc: Tuple[int, int], 
-                        nvirt: Tuple[int, int], 
-                        nelec: int
-                        ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -211,7 +208,9 @@ def _get_cas_config(self,
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_orb_number(self, nelec: int, norb: int) -> Tuple[Tuple[int, int], Tuple[int,int]]:
+    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 ___
@@ -286,7 +285,10 @@ def _create_excitation_replace(conf: List[int], iocc: int, ivirt: int) -> List[i
 
     @staticmethod
     def _append_excitations(
-        cup: List[List[int]], cdown: List[List[int]], new_cup: List[int], new_cdown: List[int]
+        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
 
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 40560859..8e17d4ac 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -2,11 +2,11 @@
 from typing import List, Tuple
 from ...scf import Molecule
 
+
 class OrbitalProjector:
-    def __init__(self, 
-                 configs: List[torch.tensor], 
-                 mol: Molecule, 
-                 cuda: bool = False) -> None:
+    def __init__(
+        self, configs: List[torch.tensor], mol: Molecule, cuda: bool = False
+    ) -> None:
         """Project the MO matrix in Slater Matrices
 
         Args:
@@ -20,31 +20,38 @@ def __init__(self,
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
-        
+
         self.device = torch.device("cpu")
         if cuda:
             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]]:
+
+    def get_unique_configs(
+        self,
+    ) -> Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]:
         """Get the unique configurations
 
         Returns:
-            Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]: 
+            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)
-
-        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))
+        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
+        )
 
+        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),
+        )
 
     def split_orbitals(
-        self,
-        mat: torch.Tensor,
-        unique_configs: bool = False
+        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
@@ -59,28 +66,34 @@ def split_orbitals(
         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)
+            out_down = torch.zeros(
+                0, nbatch, self.ndown, self.ndown, device=self.device
+            )
 
         if mat.ndim == 4:
             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 :
+            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:
             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)
+            out_down = torch.cat(
+                (out_down, mat[..., self.nup :, cdown].unsqueeze(0)), dim=0
+            )
 
         return out_up, out_down
-        
+
+
 class ExcitationMask:
     def __init__(
         self,
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index a03fdc73..5a865cae 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -103,8 +103,11 @@ def det_explicit(self, input: torch.Tensor) -> torch.Tensor:
         """
         mo_up, mo_down = self.get_slater_matrices(input)
         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)
+        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: torch.Tensor) -> torch.Tensor:
         """Computes the determinant of ground state + single + double excitations.
@@ -124,7 +127,9 @@ def det_single_double(self, input: torch.Tensor) -> torch.Tensor:
             * det_unique_down[:, self.index_unique_excitation[1]]
         )
 
-    def det_ground_state(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    def det_ground_state(
+        self, input: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the Slater determinants of the ground state.
 
         Args:
@@ -138,7 +143,9 @@ def det_ground_state(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Ten
             torch.det(input[:, self.nup :, : self.ndown]),
         )
 
-    def det_unique_single_double(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
@@ -276,7 +283,6 @@ def operator(
         if self.config_method == "ground_state":
             op_vals = self.operator_ground_state(mo, bop, op_squared)
 
-
         elif self.config_method.startswith("single"):
             if self.use_explicit_operator:
                 op_vals = self.operator_explicit(mo, bop, op_squared)
@@ -296,11 +302,11 @@ def operator(
             return op_vals
 
     def operator_ground_state(
-            self, 
-            mo: torch.Tensor, 
-            bop: torch.Tensor, 
-            op_squared: bool = False, 
-            inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+        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
 
@@ -425,11 +431,11 @@ def operator_single_double(
         )
 
     def operator_unique_single_double(
-            self, 
-            mo: torch.Tensor, 
-            bop: torch.Tensor, 
-            op_squared: bool, 
-            inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+        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
 
@@ -454,12 +460,11 @@ def operator_unique_single_double(
         do_single = len(self.exc_mask.index_unique_single_up) != 0
         do_double = len(self.exc_mask.index_unique_double_up) != 0
 
-        # compute or retrieve the inverse of the up/down MO matrices 
+        # 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]
@@ -501,10 +506,8 @@ def operator_unique_single_double(
             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:
-
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             Mdown = Mdown.view(*Mdown.shape[:-2], -1)
@@ -562,7 +565,6 @@ def operator_unique_single_double(
         # if we want the squre of the operator
         # typically trace(ABAB)
         else:
-
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -601,7 +603,6 @@ def operator_unique_single_double(
                 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,
@@ -669,12 +670,12 @@ def op_single(
 
     @staticmethod
     def op_multiexcitation(
-        baseterm: torch.Tensor, 
-        mat_exc: torch.Tensor, 
+        baseterm: torch.Tensor,
+        mat_exc: torch.Tensor,
         M: torch.Tensor,
-        index: List[int], 
-        size: int, 
-        nbatch: int
+        index: List[int],
+        size: int,
+        nbatch: int,
     ) -> torch.Tensor:
         r"""Computes the operator values for single excitation
 
@@ -707,7 +708,7 @@ def op_multiexcitation(
         # computes T @ M (after reshaping M as size x size matrices)
         # THIS IS SURPRSINGLY THE COMPUTATIONAL BOTTLENECK
         m_tmp = M[..., index].view(_m_shape)
-        op_vals =  T @ m_tmp
+        op_vals = T @ m_tmp
 
         # compute the trace
         op_vals = btrace(op_vals)
@@ -724,7 +725,7 @@ def op_squared_single(
         M: torch.Tensor,
         Y: torch.Tensor,
         index: List[int],
-        nbatch: int
+        nbatch: int,
     ) -> torch.Tensor:
         r"""Computes the operator squared for single excitation
 
@@ -769,7 +770,7 @@ def op_squared_multiexcitation(
         Y: torch.tensor,
         index: List[int],
         size: int,
-        nbatch: int
+        nbatch: int,
     ) -> torch.tensor:
         r"""Computes the operator squared for multiple excitation
 
@@ -818,12 +819,10 @@ def op_squared_multiexcitation(
         op_vals += baseterm
 
         return op_vals
-    
 
-    def compute_inverse_occupied_mo_matrix( 
-            self, 
-            mo: torch.Tensor
-            ) -> Union[Tuple[torch.Tensor, torch.Tensor], None]:
+    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:
@@ -834,11 +833,13 @@ def compute_inverse_occupied_mo_matrix(
         """
         # return None if we use the explicit calculation of all dets
         if self.config_method.startswith("cas("):
-            return None 
-        
+            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]))
+        return (
+            torch.inverse(mo[:, : self.nup, : self.nup]),
+            torch.inverse(mo[:, self.nup :, : self.ndown]),
+        )
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 232d4aa6..cf4d2e0a 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,11 +1,11 @@
 import torch
-from typing  import Union, Optional, List
+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 
+from torch.nn.utils.parametrizations import orthogonal
 import operator
 import matplotlib.pyplot as plt
 
@@ -16,7 +16,9 @@
 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.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
@@ -24,20 +26,20 @@
 from .pooling.slater_pooling import SlaterPooling
 from .pooling.orbital_configurations import OrbitalConfigurations
 from ..utils import register_extra_attributes
-from ..utils.constants import BOHR2ANGS 
+from ..utils.constants import BOHR2ANGS
 
 
 class SlaterJastrow(WaveFunction):
     def __init__(
         self,
         mol: Molecule,
-        jastrow: Optional[Union[str, nn.Module, None]] = 'default',
+        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,
-        orthogonalize_mo: bool = False
+        orthogonalize_mo: bool = False,
     ) -> None:
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
@@ -118,7 +120,7 @@ def __init__(
 
         self.log_data()
 
-    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None])-> None:
+    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None]) -> None:
         """Initialize the atomic orbital layer."""
         # self.backflow = backflow
         if backflow is None:
@@ -132,7 +134,7 @@ def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None])-> None:
         if self.cuda:
             self.ao = self.ao.to(self.device)
 
-    def init_molecular_orb(self, include_all_mo: bool)-> None:
+    def init_molecular_orb(self, include_all_mo: bool) -> None:
         """initialize the molecular orbital layers"""
 
         # determine which orbs to include in the transformation
@@ -148,7 +150,7 @@ def init_molecular_orb(self, include_all_mo: bool)-> None:
         if self.cuda:
             self.mo_scf.to(self.device)
 
-    def init_mo_mixer(self, orthogonalize_mo: bool)-> None:
+    def init_mo_mixer(self, orthogonalize_mo: bool) -> None:
         """
         Initialize the molecular orbital mixing layer.
 
@@ -174,7 +176,7 @@ def init_mo_mixer(self, orthogonalize_mo: bool)-> None:
         if self.cuda:
             self.mo.to(self.device)
 
-    def init_config(self, configs: str)-> None:
+    def init_config(self, configs: str) -> None:
         """Initialize the electronic configurations desired in the wave function."""
 
         # define the SD we want
@@ -184,7 +186,7 @@ def init_config(self, configs: str)-> None:
         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:
+    def init_slater_det_calculator(self) -> None:
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
@@ -192,7 +194,7 @@ def init_slater_det_calculator(self)-> None:
             self.configs_method, self.configs, self.mol, self.cuda
         )
 
-    def init_fc_layer(self)-> None:
+    def init_fc_layer(self) -> None:
         """Init the fc layer"""
 
         # init the layer
@@ -219,10 +221,10 @@ def init_jastrow(self, jastrow: Union[str, nn.Module, None]) -> None:
             self.use_jastrow = True
 
             # create a simple Pade Jastrow factor as default
-            if jastrow == 'default':
-                self.jastrow = JastrowFactorElectronElectron(self.mol, 
-                                                             PadeJastrowKernel, 
-                                                             cuda=self.cuda)
+            if jastrow == "default":
+                self.jastrow = JastrowFactorElectronElectron(
+                    self.mol, PadeJastrowKernel, cuda=self.cuda
+                )
 
             elif isinstance(jastrow, list):
                 self.jastrow = CombineJastrow(jastrow)
@@ -231,7 +233,7 @@ def init_jastrow(self, jastrow: Union[str, nn.Module, None]) -> None:
                 self.jastrow = jastrow
 
             else:
-                raise TypeError('Jastrow factor not supported.')
+                raise TypeError("Jastrow factor not supported.")
 
             self.jastrow_type = self.jastrow.__repr__()
             if self.cuda:
@@ -241,7 +243,9 @@ 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:
+    def init_kinetic(
+        self, kinetic: str, backflow: Union[BackFlowTransformation, None]
+    ) -> None:
         """ "Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
@@ -254,10 +258,9 @@ def init_kinetic(self, kinetic: str, backflow: Union[BackFlowTransformation,None
                 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:
+    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::
@@ -303,16 +306,17 @@ def forward(self,
         # if we do not have a Jastrow
         return self.fc(x)
 
-    def ao2mo(self, ao:torch.Tensor) -> torch.Tensor:
+    def ao2mo(self, ao: torch.Tensor) -> torch.Tensor:
         """transforms AO values in to MO values."""
 
         return self.mo(self.mo_scf(ao))
 
-    def pos2mo(self, 
-               x: torch.Tensor, 
-               derivative: Optional[int] = 0, 
-               sum_grad: Optional[bool] = True
-               ) -> torch.Tensor:
+    def pos2mo(
+        self,
+        x: torch.Tensor,
+        derivative: Optional[int] = 0,
+        sum_grad: Optional[bool] = True,
+    ) -> torch.Tensor:
         """Compute the MO vals from the pos
 
         Args:
@@ -361,11 +365,12 @@ def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         out = self.fc(kin * psi) / self.fc(psi)
         return out
 
-    def gradients_jacobi(self, 
-                         x: torch.Tensor, 
-                         sum_grad: Optional[bool] = False, 
-                         pdf: Optional[bool] = False
-                         ) -> torch.Tensor:
+    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.
 
@@ -463,13 +468,14 @@ def gradients_jacobi(self,
 
         return out
 
-    def get_kinetic_operator(self, 
-                             x: torch.Tensor, 
-                             ao: torch.Tensor, 
-                             dao: torch.Tensor, 
-                             d2ao: torch.Tensor, 
-                             mo: torch.Tensor
-                             ) -> torch.Tensor:
+    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:
@@ -532,45 +538,45 @@ def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Ten
         silent_timer = True
 
         # get ao values
-        with CodeTimer('Get AOs', silent=silent_timer):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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:
@@ -604,10 +610,12 @@ def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Ten
         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):
+    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:
@@ -655,8 +663,9 @@ def update_mo_coeffs(self) -> None:
         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:
+    def geometry(
+        self, pos: torch.Tensor, convert_to_angs: Optional[bool] = False
+    ) -> List:
         """Returns the gemoetry of the system in xyz format
 
         Args:
@@ -673,7 +682,7 @@ def geometry(self, pos: torch.Tensor,
             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.
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 52f0e1c4..dd2580ef 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -2,12 +2,14 @@
 import operator
 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.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,
 )
-from  ..scf import Molecule
+from ..scf import Molecule
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
@@ -77,7 +79,9 @@ def __init__(
 
         self.log_data()
 
-    def ordered_jastrow(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
+    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:
@@ -109,7 +113,9 @@ def permute(vals: torch.Tensor) -> torch.Tensor:
         else:
             return permute(jast_vals)
 
-    def forward(self, x: torch.Tensor, ao: Union[torch.Tensor, None]=None) -> torch.Tensor:
+    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::
@@ -159,7 +165,9 @@ def ao2mo(self, ao: torch.Tensor) -> torch.Tensor:
     def ao2cmo(self, ao, jastrow):
         return jastrow * self.mo(self.mo_scf(ao))
 
-    def pos2mo(self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
+    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)
@@ -168,7 +176,9 @@ def pos2mo(self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True) ->
         else:
             return self.ao2mo(ao.transpose(2, 3)).transpose(2, 3)
 
-    def pos2cmo(self, x: torch.Tensor, derivative:int = 0, sum_grad: bool = True) -> torch.Tensor:
+    def pos2cmo(
+        self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True
+    ) -> torch.Tensor:
         """Get the values of correlated MOs
 
         Arguments:
@@ -264,7 +274,9 @@ def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         # assemble
         return self.fc(kin * slater_dets) / self.fc(slater_dets)
 
-    def gradients_jacobi(self, x: torch.Tensor, sum_grad: bool = True, pdf: bool = False) -> torch.Tensor:
+    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:
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index b70ffccc..cc9bd121 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -5,7 +5,9 @@
 
 
 class WaveFunction(torch.nn.Module):
-    def __init__(self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False):
+    def __init__(
+        self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False
+    ):
         """
         Base class for wave functions.
 
@@ -113,10 +115,9 @@ def nuclear_repulsion(self) -> torch.Tensor:
                 vnn += Z0 * Z1 / rnn
         return vnn
 
-    def gradients_autograd(self, 
-                           pos: torch.Tensor, 
-                           pdf: Optional[bool] = False
-                           ) -> torch.Tensor:
+    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.
 
@@ -201,7 +202,7 @@ def local_energy(self, pos: torch.Tensor) -> torch.Tensor:
             + self.nuclear_repulsion()
         )
 
-    def energy(self, pos:torch.Tensor) -> torch.Tensor:
+    def energy(self, pos: torch.Tensor) -> torch.Tensor:
         """Total energy for the sampling points."""
         return torch.mean(self.local_energy(pos))
 
@@ -225,7 +226,9 @@ def _energy_variance_error(self, pos: torch.Tensor) -> torch.Tensor:
         el = self.local_energy(pos)
         return torch.mean(el), torch.var(el), self.sampling_error(el)
 
-    def pdf(self, pos: torch.Tensor, return_grad: Optional[bool]=False) -> torch.Tensor:
+    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)
@@ -239,10 +242,12 @@ def get_number_parameters(self) -> int:
                 nparam += param.data.numel()
         return nparam
 
-    def load(self, 
-             filename: str, 
-             group: Optional[str] = "wf_opt", 
-             model: Optional[str] = "best"):
+    def load(
+        self,
+        filename: str,
+        group: Optional[str] = "wf_opt",
+        model: Optional[str] = "best",
+    ):
         """Load trained parameters
 
         Args:
diff --git a/setup.py b/setup.py
index 7a354a1c..2e461ceb 100644
--- a/setup.py
+++ b/setup.py
@@ -2,54 +2,74 @@
 
 import os
 
-from setuptools import (find_packages, setup)
+from setuptools import find_packages, setup
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 # To update the package version number, edit QMCTorch/__version__.py
 version = {}
-with open(os.path.join(here, 'qmctorch', '__version__.py')) as f:
+with open(os.path.join(here, "qmctorch", "__version__.py")) as f:
     exec(f.read(), version)
 
-with open('README.md') as readme_file:
+with open("README.md") as readme_file:
     readme = readme_file.read()
 
 setup(
-    name='qmctorch',
-    version=version['__version__'],
+    name="qmctorch",
+    version=version["__version__"],
     description="Pytorch Implementation of Quantum Monte Carlo",
-    long_description=readme + '\n\n',
-    long_description_content_type='text/markdown',
+    long_description=readme + "\n\n",
+    long_description_content_type="text/markdown",
     author=["Nicolas Renaud", "Felipe Zapata"],
-    author_email='n.renaud@esciencecenter.nl',
-    url='https://github.com/NLESC-JCER/QMCTorch',
+    author_email="n.renaud@esciencecenter.nl",
+    url="https://github.com/NLESC-JCER/QMCTorch",
     packages=find_packages(),
-    package_dir={'qmctorch': 'qmctorch'},
+    package_dir={"qmctorch": "qmctorch"},
     include_package_data=True,
     license="Apache Software License 2.0",
     zip_safe=False,
-    keywords='qmctorch',
-    scripts=['bin/qmctorch'],
+    keywords="qmctorch",
+    scripts=["bin/qmctorch"],
     classifiers=[
-        'Development Status :: 4 - Beta',
-        'Intended Audience :: Science/Research',
-        'License :: OSI Approved :: Apache Software License',
-        'Natural Language :: English',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.8',
-        'Topic :: Scientific/Engineering :: Chemistry'
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: Apache Software License",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Topic :: Scientific/Engineering :: Chemistry",
+    ],
+    test_suite="tests",
+    install_requires=[
+        "matplotlib",
+        "numpy",
+        "argparse",
+        "scipy",
+        "tqdm",
+        "torch",
+        "h5py",
+        "plams",
+        "pints",
+        "linetimer",
+        "pyscf",
+        "mendeleev",
+        "twiggy",
+        "plams",
+        "ase",
+        "rdkit",
+        "dgllife",
+        "dgl",
     ],
-    test_suite='tests',
-    install_requires=['matplotlib', 'numpy', 'argparse',
-                      'scipy', 'tqdm', 'torch', 'h5py',
-                      'plams', 'pints', 'linetimer',
-                      'pyscf', 'mendeleev', 'twiggy',
-                      'plams', 'ase', 'rdkit', 'dgllife', 'dgl'],
-
     extras_require={
-        'hpc': ['horovod'],
-        'doc': ['recommonmark', 'sphinx', 'sphinx_rtd_theme', 'nbsphinx','nbconvert','jupyter'],
-        'test': ['pytest', 'pytest-runner',
-                 'coverage', 'coveralls', 'pycodestyle'],
-    }
+        "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
index aa4c6e7b..82f2f482 100644
--- a/tests/ase/test_ase_calc.py
+++ b/tests/ase/test_ase_calc.py
@@ -1,36 +1,37 @@
 import unittest
 
-from qmctorch.ase import QMCTorch     
+from qmctorch.ase import QMCTorch
 from qmctorch.ase.optimizer import TorchOptimizer
-from ase import Atoms 
+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)])
+        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'
+        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.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}
+        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.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
@@ -39,10 +40,10 @@ def setUp(self):
         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'
+        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.mode = "update"
         self.h2.calc.solver_options.resampling.resample_every = 1
         self.h2.calc.solver_options.resampling.ntherm_update = 10
 
@@ -50,19 +51,21 @@ def setUp(self):
         self.h2.calc.initialize()
 
     def test_calculate_energy(self):
-        self.h2.calc.calculate(properties=['energy'])
+        self.h2.calc.calculate(properties=["energy"])
 
     def test_calculate_forces(self):
-        self.h2.calc.calculate(properties=['forces'])
+        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 = 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 = FIRE(self.h2, trajectory="traj.xyz")
         dyn.run(fmax=0.005, steps=2)
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 6611f02c..8ac9b6c7 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,6 +1,7 @@
 import unittest
 import numpy as np
 
+
 class BaseTestSolvers:
     class BaseTestSolverMolecule(unittest.TestCase):
         def setUp(self):
@@ -15,36 +16,36 @@ def setUp(self):
 
         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 
+            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) 
+            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 
+            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) 
+            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 
+            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) 
+            batchsize = int(self.solver.sampler.walkers.nwalkers / 2)
             _ = self.solver.run(5, batchsize=batchsize)
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 3ef28871..a706545c 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
@@ -4,8 +4,12 @@
 import torch
 from torch.autograd import Variable, grad
 
-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.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
 
 set_torch_double_precision()
@@ -14,21 +18,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,9 +35,7 @@ def hess(out, pos):
 
 
 class TestGenericJastrowOrbital(unittest.TestCase):
-
     def setUp(self):
-
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -50,11 +47,11 @@ def setUp(self):
             self.mol,
             FullyConnectedJastrowKernel,
             orbital_dependent_kernel=True,
-            number_of_orbitals=self.nmo
+            number_of_orbitals=self.nmo,
         )
         self.nbatch = 11
 
-        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):
@@ -66,31 +63,25 @@ 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.reshape(
-            self.nbatch, self.nelec, 3).permute(0, 2, 1)
+        dval_grad = dval_grad.reshape(self.nbatch, self.nelec, 3).permute(0, 2, 1)
 
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
         # modules in the list !
-        assert(torch.allclose(dval.sum(0), dval_grad))
+        assert torch.allclose(dval.sum(0), 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 = 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)
+        dval_grad = (
+            dval_grad.reshape(self.nbatch, self.nelec, 3).permute(0, 2, 1).sum(-2)
+        )
 
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
@@ -98,7 +89,6 @@ def test_jacobian_jastrow(self):
         assert torch.allclose(dval.sum(0), 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)
@@ -106,8 +96,9 @@ def test_hess_jastrow(self):
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
         # modules in the list !
-        assert torch.allclose(d2val.sum(0), d2val_grad.reshape(
-            self.nbatch, self.nelec, 3).sum(2))
+        assert torch.allclose(
+            d2val.sum(0), d2val_grad.reshape(self.nbatch, self.nelec, 3).sum(2)
+        )
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index 697af246..6ade78ee 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -6,8 +6,12 @@
 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.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
 
 set_torch_double_precision()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 7d69096b..0c6128a8 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -4,8 +4,12 @@
 
 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.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
 
 set_torch_double_precision()
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 d9144999..155d4df3 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -6,8 +6,12 @@
 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.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
 
 set_torch_double_precision()
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 e5fb91da..b361fcd8 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -5,8 +5,12 @@
 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.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
 
 set_torch_double_precision()
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 533d0956..d7f57bb3 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
@@ -5,8 +5,12 @@
 
 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.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
 
 set_torch_double_precision()
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 adea59c4..a1a3b951 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
+    BoysHandyJastrowKernel,
+)
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 6a7d6890..d499d017 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
@@ -3,8 +3,12 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
+    JastrowFactorElectronElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
+    FullyConnectedJastrowKernel,
+)
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 8fabd3c6..cacf5d1f 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
@@ -3,8 +3,12 @@
 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 import FullyConnectedJastrowKernel
+from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import (
+    JastrowFactorElectronNuclei,
+)
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import (
+    FullyConnectedJastrowKernel,
+)
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 6a432f4a..72a28bd4 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
@@ -3,8 +3,12 @@
 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.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
 
 set_torch_double_precision()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_base.py b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
index 1ca1d221..6c34d0c4 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_base.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
@@ -4,6 +4,7 @@
 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)
@@ -44,21 +45,21 @@ def hess_single_element(out, inp):
 
     return hess.reshape(*shape)
 
+
 class BaseTestCases:
     class TestBackFlowKernelBase(unittest.TestCase):
-
         def setUp(self):
-            pass 
-        
+            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_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())
@@ -243,13 +244,17 @@ def test_backflow_derivative(self):
             for iq in range(nao):
                 qao = q[:, iq, ...]
                 dqao = grad(
-                    qao, self.pos, grad_outputs=torch.ones_like(self.pos), retain_graph=True
+                    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
+                        (dq_grad, dqao),
+                        axis=self.backflow_trans.backflow_kernel.stack_axis,
                     )
             # checksum
             assert torch.allclose(dq.sum(), dq_grad.sum())
@@ -294,4 +299,4 @@ def test_backflow_second_derivative(self):
             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
+            assert torch.allclose(d2q, d2q_auto)
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
index cd5736f0..bbf45046 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
@@ -6,9 +6,12 @@
 
 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.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)
@@ -32,5 +35,6 @@ def setUp(self):
         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 b4fc52d6..a341ef84 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -7,9 +7,12 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import ElectronElectronDistance
+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()
 
 torch.manual_seed(101)
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 1a19d8eb..4eed0c4a 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -6,14 +6,18 @@
 
 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.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
@@ -31,5 +35,6 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
+
 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 8457643c..101c618e 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -10,15 +10,13 @@
 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)
 
 
-
-
-
 class TestBackFlowTransformation(BaseTestCases.TestBackFlowTransformationBase):
     def setUp(self):
         # define the molecule
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
index 91983227..573dc983 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -10,13 +10,13 @@
 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
@@ -33,5 +33,6 @@ def setUp(self):
         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 64811123..63e454a7 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
@@ -10,13 +10,16 @@
 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)
 
 
-class TestOrbitalDependentBackFlowTransformation(BaseTestCases.TestOrbitalDependentBackFlowTransformationBase):
+class TestOrbitalDependentBackFlowTransformation(
+    BaseTestCases.TestOrbitalDependentBackFlowTransformationBase
+):
     def setUp(self):
         # define the molecule
         at = "C 0 0 0"
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
index 98bf9e20..9553333e 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -9,6 +9,7 @@
 
 set_torch_double_precision()
 
+
 class TestAOderivativesADF(BaseTestAO.BaseTestAOderivatives):
     def setUp(self):
         # define the molecule
diff --git a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
index 9dea37e2..a846b5f9 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -12,6 +12,7 @@
 )
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 torch.manual_seed(101)
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 db3d6db7..db4ab45d 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
@@ -12,6 +12,7 @@
 )
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 torch.manual_seed(101)
diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index 64d8e722..f0e41c51 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -18,8 +18,10 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
+
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
     def setUp(self):
         torch.manual_seed(101)
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index 8f38ad66..194ac937 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -17,6 +17,7 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 4278eb6c..3518f82b 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -11,6 +11,7 @@
 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)
@@ -28,7 +29,9 @@ def setUp(self):
         )
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel, orbital_dependent_kernel=True)
+        jastrow = JastrowFactorElectronElectron(
+            mol, PadeJastrowKernel, orbital_dependent_kernel=True
+        )
 
         self.wf = SlaterJastrow(
             mol,
@@ -57,5 +60,6 @@ def test_kinetic_energy(self):
     def test_local_energy(self):
         pass
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 018fff97..15eb18ce 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -28,6 +28,7 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 8afb6c50..186ae8d8 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -14,6 +14,7 @@
     BackFlowKernelInverse,
 )
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index b391e6b7..227d83b5 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -19,6 +19,7 @@
     BackFlowKernelInverse,
 )
 from qmctorch.utils import set_torch_double_precision
+
 set_torch_double_precision()
 
 
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index e50a2ae4..3132514e 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -10,14 +10,15 @@
 from qmctorch.solver import SolverMPI
 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.jastrow_factor_electron_electron import (
+    JastrowFactorElectronElectron,
+)
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 from qmctorch.utils import set_torch_double_precision
 
 
 class TestH2Hvd(unittest.TestCase):
-
     def setUp(self):
         hvd.init()
 
@@ -32,22 +33,21 @@ 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",
             rank=hvd.local_rank(),
-            mpi_size=hvd.local_size())
+            mpi_size=hvd.local_size(),
+        )
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(
-            self.mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
-                                configs='cas(2,2)',
-                                jastrow=jastrow,
-                                cuda=False)
+        self.wf = SlaterJastrow(
+            self.mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=False
+        )
 
         # sampler
         self.sampler = Metropolis(
@@ -56,17 +56,17 @@ def setUp(self):
             step_size=0.2,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain('atomic'),
-            move={
-                'type': 'all-elec',
-                'proba': 'normal'})
+            init=self.mol.domain("atomic"),
+            move={"type": "all-elec", "proba": "normal"},
+        )
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverMPI(wf=self.wf, sampler=self.sampler,
-                                                 optimizer=self.opt, rank=hvd.rank())
+        self.solver = SolverMPI(
+            wf=self.wf, sampler=self.sampler, optimizer=self.opt, rank=hvd.rank()
+        )
 
         # ground state energy
         self.ground_state_energy = -1.16
@@ -92,17 +92,20 @@ def test_wf_opt(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.configure(track=['local_energy'], freeze=['ao', 'mo'],
-                              loss='energy', grad='auto',
-                              ortho_mo=False, clip_loss=False,
-                              resampling={'mode': 'update',
-                                          'resample_every': 1,
-                                          'nstep_update': 50})
+        self.solver.configure(
+            track=["local_energy"],
+            freeze=["ao", "mo"],
+            loss="energy",
+            grad="auto",
+            ortho_mo=False,
+            clip_loss=False,
+            resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
+        )
         self.solver.run(10)
 
         MPI.COMM_WORLD.barrier()
 
-        self.solver.wf.load(self.solver.hdf5file, 'wf_opt')
+        self.solver.wf.load(self.solver.hdf5file, "wf_opt")
         self.solver.wf.eval()
 
         obs = self.solver.single_point()

From 6fbb4af8c7c3140828552b65be42b74680f0fe47 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 28 Feb 2025 18:58:11 +0100
Subject: [PATCH 259/286] ruff and black

---
 docs/conf.py                                  |   1 -
 docs/example/ase/h2.py                        |   4 +-
 docs/example/backflow/backflow.py             |   1 -
 docs/example/graph/jast_graph.py              |   2 -
 docs/example/optimization/h2.py               |   3 +-
 docs/notebooks/combining_jastrow.ipynb        |  13 +-
 docs/notebooks/correlation.ipynb              |  31 ++--
 docs/notebooks/create_backflow.ipynb          |  15 +-
 docs/notebooks/create_jastrow.ipynb           |  25 +++-
 docs/notebooks/geoopt.ipynb                   |  41 ++++--
 docs/notebooks/gpu.ipynb                      |  22 +--
 docs/notebooks/horovod.ipynb                  |  54 ++++---
 docs/notebooks/molecule.ipynb                 |  18 ++-
 docs/notebooks/sampling.ipynb                 |  49 ++++---
 docs/notebooks/wfopt.ipynb                    |  44 +++---
 h5x/baseimport.py                             |   8 --
 notebooks/NeuralJastrow.ipynb                 | 121 +++++++++-------
 notebooks/test.ipynb                          | 132 ++++++++++--------
 qmctorch/__init__.py                          |   1 +
 qmctorch/ase/ase.py                           |   5 +-
 qmctorch/ase/optimizer/torch_optim.py         |   4 +-
 qmctorch/sampler/metropolis_all_elec.py       |   2 +-
 .../sampler/metropolis_hasting_all_elec.py    |   2 +-
 qmctorch/sampler/pints_sampler.py             |   2 +-
 qmctorch/solver/solver.py                     |   3 +-
 qmctorch/solver/solver_base.py                |   2 +-
 qmctorch/solver/solver_mpi.py                 |   2 +-
 qmctorch/utils/torch_utils.py                 |   2 +-
 .../distance/electron_nuclei_distance.py      |   2 +-
 .../kernels/pade_jastrow_polynomial_kernel.py |   2 +-
 ...jastrow_factor_electron_electron_nuclei.py |   2 +-
 .../backflow/kernels/backflow_kernel_base.py  |   2 +-
 .../backflow/kernels/backflow_kernel_exp.py   |   1 -
 .../kernels/backflow_kernel_inverse.py        |   1 -
 .../backflow/kernels/backflow_kernel_rbf.py   |   1 -
 .../orbitals/spherical_harmonics.py           |  12 +-
 .../pooling/orbital_configurations.py         |   4 +-
 .../wavefunction/pooling/slater_pooling.py    |   2 -
 .../slater_orbital_dependent_jastrow.py       |   2 +-
 tests/solver/test_base_solver.py              |   1 -
 .../test_backflow_kernel_exp_pyscf.py         |   2 +-
 .../test_backflow_kernel_generic_pyscf.py     |   2 +-
 .../test_backflow_kernel_inverse_pyscf.py     |   2 +-
 .../test_backflow_transformation_pyscf.py     |   2 +-
 .../test_backflow_transformation_rbf_pyscf.py |   2 +-
 ...dependent_backflow_transformation_pyscf.py |   2 +-
 .../test_slater_orbital_dependent_jastrow.py  |   1 -
 47 files changed, 370 insertions(+), 284 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 1499e898..741bab07 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,7 +19,6 @@
 #
 import os
 import sys
-from unittest.mock import MagicMock
 
 
 # MOCK_CLASSES = ['torch.nn.Module']
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 7032544b..f1cfbc40 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,11 +1,9 @@
 from qmctorch.ase import QMCTorch
-from qmctorch.ase.optimizer import TorchOptimizer
 from ase import Atoms
-from ase.optimize import GoodOldQuasiNewton, FIRE
+from ase.optimize import 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)
diff --git a/docs/example/backflow/backflow.py b/docs/example/backflow/backflow.py
index 48a8144b..836fca3a 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -1,4 +1,3 @@
-from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 import torch
 from torch import nn
 
diff --git a/docs/example/graph/jast_graph.py b/docs/example/graph/jast_graph.py
index 0fee14d4..754e9ecf 100644
--- a/docs/example/graph/jast_graph.py
+++ b/docs/example/graph/jast_graph.py
@@ -1,10 +1,8 @@
 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
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 41354569..903c2bc0 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -5,9 +5,8 @@
 from qmctorch.scf import Molecule
 
 from qmctorch.solver import Solver
-from qmctorch.sampler import Metropolis, Hamiltonian
+from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-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
 
diff --git a/docs/notebooks/combining_jastrow.ipynb b/docs/notebooks/combining_jastrow.ipynb
index 2861fd47..2a80d778 100644
--- a/docs/notebooks/combining_jastrow.ipynb
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -85,11 +85,12 @@
    ],
    "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)"
+    "    atom=\"Li 0 0 0; H 0 0 3.14\",\n",
+    "    unit=\"bohr\",\n",
+    "    calculator=\"pyscf\",\n",
+    "    basis=\"sto-3g\",\n",
+    "    redo_scf=True,\n",
+    ")"
    ]
   },
   {
@@ -170,7 +171,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec*3)\n",
+    "pos = torch.rand(10, wf.nelec * 3)\n",
     "print(wf(pos))"
    ]
   }
diff --git a/docs/notebooks/correlation.ipynb b/docs/notebooks/correlation.ipynb
index 876ee1eb..0f6cc70c 100644
--- a/docs/notebooks/correlation.ipynb
+++ b/docs/notebooks/correlation.ipynb
@@ -33,8 +33,11 @@
     "from qmctorch.sampler import Metropolis\n",
     "from qmctorch.solver import Solver\n",
     "from qmctorch.utils import set_torch_double_precision\n",
-    "from qmctorch.utils.plot_data import blocking, plot_blocking_energy\n",
-    "from qmctorch.utils.plot_data  import plot_correlation_coefficient, plot_integrated_autocorrelation_time"
+    "from qmctorch.utils.plot_data import plot_blocking_energy\n",
+    "from qmctorch.utils.plot_data import (\n",
+    "    plot_correlation_coefficient,\n",
+    "    plot_integrated_autocorrelation_time,\n",
+    ")"
    ]
   },
   {
@@ -74,7 +77,9 @@
    ],
    "source": [
     "set_torch_double_precision()\n",
-    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
+    "mol = Molecule(\n",
+    "    atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\", redo_scf=True\n",
+    ")"
    ]
   },
   {
@@ -100,7 +105,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs='ground_state')"
+    "wf = SlaterJastrow(mol, configs=\"ground_state\")"
    ]
   },
   {
@@ -134,11 +139,17 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
-    "                    nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                    init=mol.domain('normal'),\n",
-    "                    ntherm=0, ndecor=1,\n",
-    "                    move={'type': 'all-elec', 'proba': 'normal'})"
+    "sampler = Metropolis(\n",
+    "    nwalkers=100,\n",
+    "    nstep=500,\n",
+    "    step_size=0.25,\n",
+    "    nelec=wf.nelec,\n",
+    "    ndim=wf.ndim,\n",
+    "    init=mol.domain(\"normal\"),\n",
+    "    ntherm=0,\n",
+    "    ndecor=1,\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    ")"
    ]
   },
   {
@@ -318,7 +329,7 @@
     }
    ],
    "source": [
-    "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers='mean')"
+    "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers=\"mean\")"
    ]
   },
   {
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index 43f8b237..84c3e1d9 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -47,7 +47,7 @@
     "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)"
+    "mol = Molecule(atom=\"H 0. 0. 0; H 0. 0. 1.\", unit=\"bohr\", redo_scf=True)"
    ]
   },
   {
@@ -65,15 +65,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from torch import nn \n",
+    "from torch import nn\n",
+    "\n",
+    "\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",
+    "\n",
     "    def _backflow_kernel(self, x):\n",
     "        original_shape = x.shape\n",
-    "        x = x.reshape(-1,1)\n",
+    "        x = x.reshape(-1, 1)\n",
     "        x = self.fc2(self.fc1(x))\n",
     "        return x.reshape(*original_shape)"
    ]
@@ -92,7 +95,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "backflow = BackFlowTransformation(mol, MyBackflowKernel, backflow_kernel_kwargs={'size': 8})"
+    "backflow = BackFlowTransformation(\n",
+    "    mol, MyBackflowKernel, backflow_kernel_kwargs={\"size\": 8}\n",
+    ")"
    ]
   },
   {
@@ -152,7 +157,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec*3)\n",
+    "pos = torch.rand(10, wf.nelec * 3)\n",
     "print(wf(pos))"
    ]
   }
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index de55cc49..76592eb9 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -31,8 +31,12 @@
     "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"
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
+    "    JastrowFactorElectronElectron,\n",
+    ")\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
+    "    JastrowKernelElectronElectronBase,\n",
+    ")"
    ]
   },
   {
@@ -61,7 +65,9 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
+    "mol = Molecule(\n",
+    "    atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\", redo_scf=True\n",
+    ")"
    ]
   },
   {
@@ -79,15 +85,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from torch import nn \n",
+    "from torch import nn\n",
+    "\n",
+    "\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",
     "        self.fc2 = nn.Linear(size, 1, bias=False)\n",
+    "\n",
     "    def forward(self, x):\n",
     "        nbatch, npair = x.shape\n",
-    "        x = x.reshape(-1,1)\n",
+    "        x = x.reshape(-1, 1)\n",
     "        x = self.fc2(self.fc1(x))\n",
     "        return x.reshape(nbatch, npair)"
    ]
@@ -118,7 +127,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel, kernel_kwargs={'size': 64})"
+    "jastrow = JastrowFactorElectronElectron(\n",
+    "    mol, MyJastrowKernel, kernel_kwargs={\"size\": 64}\n",
+    ")"
    ]
   },
   {
@@ -178,7 +189,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec*3)\n",
+    "pos = torch.rand(10, wf.nelec * 3)\n",
     "print(wf(pos))"
    ]
   },
diff --git a/docs/notebooks/geoopt.ipynb b/docs/notebooks/geoopt.ipynb
index f47d6c37..2ed0f642 100644
--- a/docs/notebooks/geoopt.ipynb
+++ b/docs/notebooks/geoopt.ipynb
@@ -35,6 +35,7 @@
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.utils.plot_data import plot_energy\n",
     "from qmctorch.utils import set_torch_double_precision\n",
+    "\n",
     "set_torch_double_precision()"
    ]
   },
@@ -70,8 +71,13 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom = 'H 0. 0. -0.5; H 0. 0. 0.5', unit='bohr', \n",
-    "               calculator='pyscf', basis='sto-3g', redo_scf=True)"
+    "mol = Molecule(\n",
+    "    atom=\"H 0. 0. -0.5; H 0. 0. 0.5\",\n",
+    "    unit=\"bohr\",\n",
+    "    calculator=\"pyscf\",\n",
+    "    basis=\"sto-3g\",\n",
+    "    redo_scf=True,\n",
+    ")"
    ]
   },
   {
@@ -126,14 +132,20 @@
    ],
    "source": [
     "# wave function with only the ground state determinant\n",
-    "wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()\n",
+    "wf = SlaterJastrow(mol, configs=\"single_double(2,2)\").gto2sto()\n",
     "\n",
     "# sampler\n",
-    "sampler = Metropolis(nwalkers=1000, nstep=200, step_size=0.5,\n",
-    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                     ntherm=-1, ndecor=100,\n",
-    "                     init=mol.domain('normal'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'})\n",
+    "sampler = Metropolis(\n",
+    "    nwalkers=1000,\n",
+    "    nstep=200,\n",
+    "    step_size=0.5,\n",
+    "    nelec=wf.nelec,\n",
+    "    ndim=wf.ndim,\n",
+    "    ntherm=-1,\n",
+    "    ndecor=100,\n",
+    "    init=mol.domain(\"normal\"),\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    ")\n",
     "# optimizer\n",
     "opt = Adam(wf.parameters(), lr=0.005)\n",
     "\n",
@@ -159,11 +171,10 @@
     }
    ],
    "source": [
-    "solver = Solver(wf=wf,\n",
-    "                       sampler=sampler,\n",
-    "                       optimizer=opt,\n",
-    "                       scheduler=None)\n",
-    "solver.configure(loss='energy', grad='auto', track=['local_energy','geometry'], freeze = ['ao'])"
+    "solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)\n",
+    "solver.configure(\n",
+    "    loss=\"energy\", grad=\"auto\", track=[\"local_energy\", \"geometry\"], freeze=[\"ao\"]\n",
+    ")"
    ]
   },
   {
@@ -452,7 +463,7 @@
    ],
    "source": [
     "solver.set_params_requires_grad(wf_params=False, geo_params=True)\n",
-    "obs = solver.run(50)\n"
+    "obs = solver.run(50)"
    ]
   },
   {
@@ -461,7 +472,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.save_traj('h2_traj.xyz', obs)"
+    "solver.save_traj(\"h2_traj.xyz\", obs)"
    ]
   },
   {
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
index 3f49e7fc..8f9afe4d 100644
--- a/docs/notebooks/gpu.ipynb
+++ b/docs/notebooks/gpu.ipynb
@@ -24,12 +24,11 @@
    "outputs": [],
    "source": [
     "import torch\n",
-    "from torch import optim\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
-    "from qmctorch.utils import (plot_energy, plot_data)\n",
-    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
+    "\n",
+    "mol = Molecule(atom=\"H 0. 0. 0; H 0. 0. 1.\", unit=\"bohr\", redo_scf=True)"
    ]
   },
   {
@@ -49,13 +48,18 @@
    "source": [
     "if torch.cuda.is_available():\n",
     "    wf = SlaterJastrow(mol, cuda=True)\n",
-    "    sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
-    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                     init=mol.domain('atomic'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
-    "                     cuda=True)\n",
+    "    sampler = Metropolis(\n",
+    "        nwalkers=100,\n",
+    "        nstep=500,\n",
+    "        step_size=0.25,\n",
+    "        nelec=wf.nelec,\n",
+    "        ndim=wf.ndim,\n",
+    "        init=mol.domain(\"atomic\"),\n",
+    "        move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    "        cuda=True,\n",
+    "    )\n",
     "else:\n",
-    "    print('CUDA not available, install torch with cuda support to proceed')"
+    "    print(\"CUDA not available, install torch with cuda support to proceed\")"
    ]
   }
  ],
diff --git a/docs/notebooks/horovod.ipynb b/docs/notebooks/horovod.ipynb
index a3e49937..0527bc33 100644
--- a/docs/notebooks/horovod.ipynb
+++ b/docs/notebooks/horovod.ipynb
@@ -25,10 +25,10 @@
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
-    "from qmctorch.utils import (plot_energy, plot_data)\n",
     "from qmctorch.utils import set_torch_double_precision\n",
+    "\n",
     "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.\", unit=\"bohr\", redo_scf=True)"
    ]
   },
   {
@@ -54,11 +54,16 @@
    "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, cuda=use_gpu).gto2sto()\n",
-    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
-    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                     init=mol.domain('atomic'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
-    "                     cuda=use_gpu)"
+    "sampler = Metropolis(\n",
+    "    nwalkers=100,\n",
+    "    nstep=500,\n",
+    "    step_size=0.25,\n",
+    "    nelec=wf.nelec,\n",
+    "    ndim=wf.ndim,\n",
+    "    init=mol.domain(\"atomic\"),\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    "    cuda=use_gpu,\n",
+    ")"
    ]
   },
   {
@@ -67,11 +72,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},\n",
-    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
-    "           {'params': wf.mo.parameters(), 'lr': 1E-3},\n",
-    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
-    "opt = optim.Adam(lr_dict, lr=1E-3)"
+    "lr_dict = [\n",
+    "    {\"params\": wf.jastrow.parameters(), \"lr\": 3e-3},\n",
+    "    {\"params\": wf.ao.parameters(), \"lr\": 1e-6},\n",
+    "    {\"params\": wf.mo.parameters(), \"lr\": 1e-3},\n",
+    "    {\"params\": wf.fc.parameters(), \"lr\": 2e-3},\n",
+    "]\n",
+    "opt = optim.Adam(lr_dict, lr=1e-3)"
    ]
   },
   {
@@ -94,10 +101,8 @@
     "hvd.init()\n",
     "if torch.cuda.is_available():\n",
     "    torch.cuda.set_device(hvd.rank())\n",
-    "    \n",
-    "solver = SolverMPI(wf=wf, sampler=sampler,\n",
-    "                                    optimizer=opt,\n",
-    "                                    rank=hvd.rank())"
+    "\n",
+    "solver = SolverMPI(wf=wf, sampler=sampler, optimizer=opt, rank=hvd.rank())"
    ]
   },
   {
@@ -106,15 +111,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(track=['local_energy'], freeze=['ao', 'mo'],\n",
-    "                loss='energy', grad='auto',\n",
-    "                ortho_mo=False, clip_loss=False,\n",
-    "                resampling={'mode': 'update',\n",
-    "                            'resample_every': 1,\n",
-    "                            'nstep_update': 50})\n",
+    "solver.configure(\n",
+    "    track=[\"local_energy\"],\n",
+    "    freeze=[\"ao\", \"mo\"],\n",
+    "    loss=\"energy\",\n",
+    "    grad=\"auto\",\n",
+    "    ortho_mo=False,\n",
+    "    clip_loss=False,\n",
+    "    resampling={\"mode\": \"update\", \"resample_every\": 1, \"nstep_update\": 50},\n",
+    ")\n",
     "\n",
     "# optimize the wave function\n",
-    "obs = solver.run(5)\n"
+    "obs = solver.run(5)"
    ]
   },
   {
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
index 99710989..c114a785 100644
--- a/docs/notebooks/molecule.ipynb
+++ b/docs/notebooks/molecule.ipynb
@@ -79,7 +79,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr')"
+    "mol = Molecule(atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\")"
    ]
   },
   {
@@ -123,7 +123,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom='h2.xyz', unit='bohr', calculator='pyscf', redo_scf=True)"
+    "mol = Molecule(atom=\"h2.xyz\", unit=\"bohr\", calculator=\"pyscf\", redo_scf=True)"
    ]
   },
   {
@@ -177,7 +177,13 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='pyscf', basis='sto-6g', redo_scf=True)"
+    "mol = Molecule(\n",
+    "    atom=\"H 0. 0. 0; H 0. 0. 1.\",\n",
+    "    unit=\"bohr\",\n",
+    "    calculator=\"pyscf\",\n",
+    "    basis=\"sto-6g\",\n",
+    "    redo_scf=True,\n",
+    ")"
    ]
   },
   {
@@ -235,7 +241,9 @@
    ],
    "source": [
     "try:\n",
-    "    mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='adf', basis='dzp')\n",
+    "    mol = Molecule(\n",
+    "        atom=\"H 0. 0. 0; H 0. 0. 1.\", unit=\"bohr\", calculator=\"adf\", basis=\"dzp\"\n",
+    "    )\n",
     "except Exception as expt:\n",
     "    print(expt)"
    ]
@@ -288,7 +296,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(load='./hdf5/LiH_adf_dz.hdf5')"
+    "mol = Molecule(load=\"./hdf5/LiH_adf_dz.hdf5\")"
    ]
   }
  ],
diff --git a/docs/notebooks/sampling.ipynb b/docs/notebooks/sampling.ipynb
index d1b83cfb..e20ce865 100644
--- a/docs/notebooks/sampling.ipynb
+++ b/docs/notebooks/sampling.ipynb
@@ -27,8 +27,7 @@
     }
    ],
    "source": [
-    "import numpy as np \n",
-    "import matplotlib.pyplot as plt \n",
+    "import matplotlib.pyplot as plt\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
@@ -78,8 +77,9 @@
    ],
    "source": [
     "# define the molecule\n",
-    "mol = Molecule(atom='water.xyz', unit='angs',\n",
-    "               calculator='pyscf', basis='sto-3g', name='water')"
+    "mol = Molecule(\n",
+    "    atom=\"water.xyz\", unit=\"angs\", calculator=\"pyscf\", basis=\"sto-3g\", name=\"water\"\n",
+    ")"
    ]
   },
   {
@@ -117,7 +117,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs='ground_state')"
+    "wf = SlaterJastrow(mol, configs=\"ground_state\")"
    ]
   },
   {
@@ -151,10 +151,15 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
-    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                     init=mol.domain('atomic'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+    "sampler = Metropolis(\n",
+    "    nwalkers=100,\n",
+    "    nstep=500,\n",
+    "    step_size=0.25,\n",
+    "    nelec=wf.nelec,\n",
+    "    ndim=wf.ndim,\n",
+    "    init=mol.domain(\"atomic\"),\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    ")"
    ]
   },
   {
@@ -245,8 +250,8 @@
    ],
    "source": [
     "pos = sampler(wf.pdf)\n",
-    "pos = pos.reshape(100,10,3).cpu().detach().numpy()\n",
-    "plt.scatter(pos[:,:,0],pos[:,:,1],s=0.5)"
+    "pos = pos.reshape(100, 10, 3).cpu().detach().numpy()\n",
+    "plt.scatter(pos[:, :, 0], pos[:, :, 1], s=0.5)"
    ]
   },
   {
@@ -281,11 +286,17 @@
     }
    ],
    "source": [
-    "sampler_singlewalker = Metropolis(nwalkers=1, nstep=500, step_size=0.25,\n",
-    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
-    "                     ntherm=0, ndecor=1,\n",
-    "                     init=mol.domain('atomic'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+    "sampler_singlewalker = Metropolis(\n",
+    "    nwalkers=1,\n",
+    "    nstep=500,\n",
+    "    step_size=0.25,\n",
+    "    nelec=wf.nelec,\n",
+    "    ndim=wf.ndim,\n",
+    "    ntherm=0,\n",
+    "    ndecor=1,\n",
+    "    init=mol.domain(\"atomic\"),\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    ")"
    ]
   },
   {
@@ -348,8 +359,8 @@
    ],
    "source": [
     "pos = sampler_singlewalker(wf.pdf)\n",
-    "pos = pos.reshape(-1,10,3).detach().numpy()\n",
-    "plt.plot(pos[:,:,0], pos[:,:,1], marker=\"o\", ls='--')"
+    "pos = pos.reshape(-1, 10, 3).detach().numpy()\n",
+    "plt.plot(pos[:, :, 0], pos[:, :, 1], marker=\"o\", ls=\"--\")"
    ]
   },
   {
@@ -508,7 +519,7 @@
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)\n",
-    "plot_walkers_traj(obs.local_energy, walkers='mean')"
+    "plot_walkers_traj(obs.local_energy, walkers=\"mean\")"
    ]
   }
  ],
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
index 214b5a9c..34745df4 100644
--- a/docs/notebooks/wfopt.ipynb
+++ b/docs/notebooks/wfopt.ipynb
@@ -34,6 +34,7 @@
     "from qmctorch.sampler import Metropolis\n",
     "from qmctorch.utils import set_torch_double_precision\n",
     "from qmctorch.utils.plot_data import plot_energy\n",
+    "\n",
     "set_torch_double_precision()"
    ]
   },
@@ -63,7 +64,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(load='./hdf5/H2_adf_dzp.hdf5')"
+    "mol = Molecule(load=\"./hdf5/H2_adf_dzp.hdf5\")"
    ]
   },
   {
@@ -98,7 +99,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs='single_double(2,2)')"
+    "wf = SlaterJastrow(mol, configs=\"single_double(2,2)\")"
    ]
   },
   {
@@ -133,11 +134,16 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(nwalkers=5000,\n",
-    "                     nstep=200, step_size=0.2,\n",
-    "                     ntherm=-1, ndecor=100,\n",
-    "                     nelec=wf.nelec, init=mol.domain('atomic'),\n",
-    "                     move={'type': 'all-elec', 'proba': 'normal'})"
+    "sampler = Metropolis(\n",
+    "    nwalkers=5000,\n",
+    "    nstep=200,\n",
+    "    step_size=0.2,\n",
+    "    ntherm=-1,\n",
+    "    ndecor=100,\n",
+    "    nelec=wf.nelec,\n",
+    "    init=mol.domain(\"atomic\"),\n",
+    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    ")"
    ]
   },
   {
@@ -154,11 +160,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},\n",
-    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
-    "           {'params': wf.mo.parameters(), 'lr': 2E-3},\n",
-    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
-    "opt = optim.Adam(lr_dict, lr=1E-3)\n"
+    "lr_dict = [\n",
+    "    {\"params\": wf.jastrow.parameters(), \"lr\": 1e-2},\n",
+    "    {\"params\": wf.ao.parameters(), \"lr\": 1e-6},\n",
+    "    {\"params\": wf.mo.parameters(), \"lr\": 2e-3},\n",
+    "    {\"params\": wf.fc.parameters(), \"lr\": 2e-3},\n",
+    "]\n",
+    "opt = optim.Adam(lr_dict, lr=1e-3)"
    ]
   },
   {
@@ -220,7 +228,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(track=['local_energy', 'parameters'])"
+    "solver.configure(track=[\"local_energy\", \"parameters\"])"
    ]
   },
   {
@@ -237,7 +245,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(freeze=['ao'])"
+    "solver.configure(freeze=[\"ao\"])"
    ]
   },
   {
@@ -253,7 +261,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(loss='energy')"
+    "solver.configure(loss=\"energy\")"
    ]
   },
   {
@@ -270,7 +278,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(grad='manual')"
+    "solver.configure(grad=\"manual\")"
    ]
   },
   {
@@ -287,9 +295,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(resampling={'mode': 'update',\n",
-    "                            'resample_every': 1,\n",
-    "                            'nstep_update': 25})"
+    "solver.configure(resampling={\"mode\": \"update\", \"resample_every\": 1, \"nstep_update\": 25})"
    ]
   },
   {
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 9a1e941d..09411dff 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,11 +1,3 @@
-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" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
diff --git a/notebooks/NeuralJastrow.ipynb b/notebooks/NeuralJastrow.ipynb
index edb840e8..c9f5f550 100644
--- a/notebooks/NeuralJastrow.ipynb
+++ b/notebooks/NeuralJastrow.ipynb
@@ -16,9 +16,7 @@
      ]
     }
    ],
-   "source": [
-    "import qmctorch"
-   ]
+   "source": []
   },
   {
    "cell_type": "markdown",
@@ -63,7 +61,9 @@
    "outputs": [],
    "source": [
     "import torch\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
+    "    JastrowFactorElectronElectron,\n",
+    ")\n",
     "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel\n",
     "\n",
     "# number of spin up/down electrons\n",
@@ -72,9 +72,8 @@
     "\n",
     "# define the jastrow factor\n",
     "jastrow = JastrowFactorElectronElectron(\n",
-    "            nup, ndown,\n",
-    "            PadeJastrowKernel,\n",
-    "            kernel_kwargs={'w': 0.1})\n",
+    "    nup, ndown, PadeJastrowKernel, kernel_kwargs={\"w\": 0.1}\n",
+    ")\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -102,7 +101,9 @@
    "outputs": [],
    "source": [
     "import torch\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
+    "    JastrowFactorElectronElectron,\n",
+    ")\n",
     "from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel\n",
     "\n",
     "# number of spin up/down electrons\n",
@@ -111,9 +112,8 @@
     "\n",
     "# define the jastrow factor\n",
     "jastrow = JastrowFactorElectronElectron(\n",
-    "            nup, ndown,\n",
-    "            FullyConnectedJastrowKernel,\n",
-    "            kernel_kwargs={'size1': 32, 'size2': 64})\n",
+    "    nup, ndown, FullyConnectedJastrowKernel, kernel_kwargs={\"size1\": 32, \"size2\": 64}\n",
+    ")\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -170,20 +170,23 @@
     "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",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
+    "    PadeJastrowKernel,\n",
+    "    FullyConnectedJastrowKernel,\n",
+    ")\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",
+    "    atom=\"Li 0 0 0; H 0 0 3.14\", unit=\"bohr\", calculator=\"pyscf\", basis=\"sto-3g\"\n",
+    ")\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",
+    "wf = SlaterJastrow(\n",
+    "    mol,\n",
+    "    jastrow_kernel=PadeJastrowKernel,\n",
+    "    jastrow_kernel_kwargs={\"w\": 0.1},\n",
+    "    configs=\"single_double(2,2)\",\n",
+    ")\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -222,20 +225,23 @@
     "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",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
+    "    PadeJastrowKernel,\n",
+    "    FullyConnectedJastrowKernel,\n",
+    ")\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",
+    "    atom=\"Li 0 0 0; H 0 0 3.014\", unit=\"bohr\", calculator=\"pyscf\", basis=\"sto-3g\"\n",
+    ")\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",
+    "wf = SlaterJastrow(\n",
+    "    mol,\n",
+    "    jastrow_kernel=FullyConnectedJastrowKernel,\n",
+    "    jastrow_kernel_kwargs={\"size1\": 32, \"size2\": 64},\n",
+    "    configs=\"single_double(2,2)\",\n",
+    ")\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -262,13 +268,18 @@
    "source": [
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel, FullyConnectedJastrowKernel\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
+    "    PadeJastrowKernel,\n",
+    "    FullyConnectedJastrowKernel,\n",
+    ")\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",
+    "    mol = Molecule(\n",
+    "        atom=\"H 0 0 -0.69; H 0. 0. 0.69\", calculator=\"adf\", basis=\"dzp\", unit=\"bohr\"\n",
+    "    )\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",
@@ -280,39 +291,45 @@
     "    # 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",
+    "    wf = SlaterJastrow(\n",
+    "        mol,\n",
+    "        jastrow_kernel=FullyConnectedJastrowKernel,\n",
+    "        jastrow_kernel_kwargs={\"size1\": 32, \"size2\": 64},\n",
+    "        configs=\"single_double(4,12)\",\n",
+    "    )\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",
+    "    sampler = Metropolis(\n",
+    "        nwalkers=10000,\n",
+    "        nstep=2000,\n",
+    "        step_size=0.05,\n",
+    "        ntherm=-1,\n",
+    "        ndecor=100,\n",
+    "        nelec=wf.nelec,\n",
+    "        init=mol.domain(\"atomic\"),\n",
+    "        move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
+    "        cuda=cuda,\n",
+    "    )\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",
+    "    lr_dict = [\n",
+    "        {\"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",
+    "    ]\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",
+    "    solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=scheduler)\n",
     "\n",
     "    # optimize the wave function\n",
-    "    solver.track_observable(['local_energy', 'parameters'])\n",
+    "    solver.track_observable([\"local_energy\", \"parameters\"])\n",
     "\n",
-    "    solver.configure_resampling(mode='update',\n",
-    "                                resample_every=1,\n",
-    "                                nstep_update=100)\n",
+    "    solver.configure_resampling(mode=\"update\", resample_every=1, nstep_update=100)\n",
     "    solver.ortho_mo = False\n",
     "\n",
     "    obs = solver.run(500, batchsize=200)"
diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index 47f98cd7..3ef64bf4 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -1,28 +1,4 @@
 {
- "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",
@@ -30,8 +6,8 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
       "INFO:QMCTorch|  ____    __  ______________             _\n",
       "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
@@ -55,12 +31,14 @@
    ],
    "source": [
     "from qmctorch.scf import Molecule\n",
+    "\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)"
+    "    atom=\"Li 0 0 0; H 0 0 3.015\",\n",
+    "    unit=\"bohr\",\n",
+    "    calculator=\"pyscf\",\n",
+    "    basis=\"sto-3g\",\n",
+    "    redo_scf=True,\n",
+    ")"
    ]
   },
   {
@@ -69,8 +47,8 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stderr",
+     "output_type": "stream",
      "text": [
       "Using backend: pytorch\n"
      ]
@@ -78,8 +56,12 @@
    ],
    "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.atomic_orbitals_backflow import (\n",
+    "    AtomicOrbitalsBackFlow,\n",
+    ")\n",
+    "from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (\n",
+    "    BackFlowTransformation,\n",
+    ")\n",
     "from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse\n",
     "\n",
     "\n",
@@ -90,24 +72,25 @@
    ]
   },
   {
-   "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,
+   "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
       "torch.Size([11, 4, 6, 3])\ntorch.Size([4, 11, 4, 6])\n"
      ]
     }
+   ],
+   "source": [
+    "import torch\n",
+    "\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)"
    ]
   },
   {
@@ -116,27 +99,30 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "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.slater_jastrow import SlaterJastrow\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
+    "    JastrowFactorElectronElectron,\n",
+    ")\n",
     "from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel\n",
     "\n",
-    "jastrow = JastrowFactorElectronElectron(\n",
-    "            mol, PadeJastrowKernel)\n",
+    "jastrow = JastrowFactorElectronElectron(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)"
+    "wf = SlaterJastrow(\n",
+    "    mol,\n",
+    "    kinetic=\"jacobi\",\n",
+    "    include_all_mo=True,\n",
+    "    configs=\"single_double(2,2)\",\n",
+    "    jastrow=jastrow,\n",
+    "    backflow=bf,\n",
+    ")"
    ]
   },
   {
@@ -145,14 +131,13 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "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",
@@ -383,12 +368,13 @@
        "           -9.2339e-02]]]], grad_fn=<UnsafeViewBackward>)"
       ]
      },
+     "execution_count": 20,
      "metadata": {},
-     "execution_count": 20
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "wf.ao2mo(wf.ao(pos,1))"
+    "wf.ao2mo(wf.ao(pos, 1))"
    ]
   },
   {
@@ -397,14 +383,13 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "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",
@@ -420,8 +405,9 @@
        "        [ -1.5769]], grad_fn=<MulBackward0>)"
       ]
      },
+     "execution_count": 27,
      "metadata": {},
-     "execution_count": 27
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -435,5 +421,29 @@
    "outputs": [],
    "source": []
   }
- ]
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "7ce898621bfdc1ef835a37ba44cfccabe14bea8b663e0a8a268cd00c3f89209b"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 64-bit ('qmctorch': conda)",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
 }
\ No newline at end of file
diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index a701e0b7..9dc5f942 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
+
 from .__version__ import __version__
 
 
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 5ff3f0bd..8c7a649f 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -1,4 +1,4 @@
-from ase.calculators.calculator import Calculator, all_changes
+from ase.calculators.calculator import Calculator
 from ase import Atoms
 import numpy as np
 import torch
@@ -15,7 +15,6 @@
 )
 from ..solver import Solver
 from ..sampler import Metropolis
-from .. import log
 
 
 class QMCTorch(Calculator):
@@ -27,7 +26,7 @@ def __init__(
         *,
         labels: list = None,
         atoms: Atoms = None,
-        **kwargs: dict
+        **kwargs: dict,
     ) -> None:
         """
         Initialize a QMCTorchCalculator object.
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index 5f3c9fd0..db49b06e 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -1,4 +1,4 @@
-from typing import IO, Any, Callable, Dict, List, Optional, Union
+from typing import IO, Optional, Union
 from types import SimpleNamespace
 from torch.optim import SGD
 from torch.optim import Optimizer as torch_optimizer
@@ -8,8 +8,6 @@
 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):
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index b7a66c29..4a925d9d 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -76,7 +76,7 @@ def log_data(self) -> None:
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
+        func: Callable[[torch.Tensor], torch.Tensor],
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the log of a function
 
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index 584c3753..a96de08f 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -66,7 +66,7 @@ def log_data(self) -> None:
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
+        func: Callable[[torch.Tensor], torch.Tensor],
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of  a function
 
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index befbe65b..5a27d2b1 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -115,7 +115,7 @@ def log_data(self):
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
+        func: Callable[[torch.Tensor], torch.Tensor],
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of a function
 
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 2b3b9fba..9bc86557 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -1,8 +1,7 @@
-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
+from typing import Optional, Dict, List, Tuple, Any
 import torch
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 9cc441d3..0d756195 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -177,7 +177,7 @@ def store_observable(
         pos: torch.tensor,
         local_energy: Optional[torch.tensor] = None,
         ibatch: Optional[int] = None,
-        **kwargs
+        **kwargs,
     ):
         """store observale in the dictionary
 
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index d2836582..c764f54e 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -1,6 +1,6 @@
 from time import time
 from types import SimpleNamespace
-from typing import Optional, Dict, Union, List, Tuple, Any
+from typing import Optional
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
 
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index c9cc8d25..f485f6a6 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,4 +1,4 @@
-from typing import Optional, ContextManager, Tuple
+from typing import Optional
 import torch
 from torch import nn
 from torch.autograd import grad, Variable
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index 93029b9b..da7f590b 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from typing import Optional, Tuple, Union
+from typing import Tuple, Union
 from .scaling import (
     get_scaled_distance,
     get_der_scaled_distance,
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 79ef5b8d..2762c36b 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,6 +1,6 @@
 import torch
 from torch import nn
-from typing import Union, Optional
+from typing import Union
 from .....utils import register_extra_attributes
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
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 ab4eb1f8..7860aa2d 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,7 +1,7 @@
 import torch
 from torch import nn
 from torch.autograd import Variable, grad
-from typing import Dict, Tuple, Optional, List, Union
+from typing import Dict, Tuple, Union
 from ..distance.electron_electron_distance import ElectronElectronDistance
 from ..distance.electron_nuclei_distance import ElectronNucleiDistance
 from ....scf import Molecule
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 22eb6243..71e1dfea 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,7 +1,7 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-from typing import Tuple, List, Union
+from typing import Tuple, Union
 from .....scf import Molecule
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index db0e71c0..e7c063a6 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -2,7 +2,6 @@
 from torch import nn
 
 from .....scf import Molecule
-from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 993faaa2..7238ca99 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -2,7 +2,6 @@
 from torch import nn
 
 from .....scf import Molecule
-from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
index 44ae9889..9a4cb7d8 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -3,7 +3,6 @@
 from torch.nn import functional as F
 
 from .....scf import Molecule
-from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 0f2b42d4..6f507779 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -519,7 +519,11 @@ def _spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
         c0 = 0.31539156525252005
         return (
             c0
-            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
+            * (
+                -(xyz[:, :, :, 0] ** 2)
+                - xyz[:, :, :, 1] ** 2
+                + 2 * xyz[:, :, :, 2] ** 2
+            )
             / r2
         )
     if m == 2:
@@ -554,7 +558,11 @@ def _nabla_spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
         return c0 * (
             (-2 * xyz[:, :, :, 0] - 2 * xyz[:, :, :, 1] + 4 * xyz[:, :, :, 2]) / r2
             - 2
-            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
+            * (
+                -(xyz[:, :, :, 0] ** 2)
+                - xyz[:, :, :, 1] ** 2
+                + 2 * xyz[:, :, :, 2] ** 2
+            )
             * xyz.sum(3)
             / r3
         )
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index e7c891ec..9848c006 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -308,7 +308,7 @@ def _append_excitations(
 
 
 def get_excitation(
-    configs: Tuple[torch.LongTensor, torch.LongTensor]
+    configs: Tuple[torch.LongTensor, torch.LongTensor],
 ) -> Tuple[List[List[List[int]]], List[List[List[int]]]]:
     """Get the excitation data
 
@@ -350,7 +350,7 @@ def get_excitation(
 
 
 def get_unique_excitation(
-    configs: Tuple[torch.LongTensor, torch.LongTensor]
+    configs: Tuple[torch.LongTensor, torch.LongTensor],
 ) -> Tuple[Tuple[List[List[int]], List[List[int]]], Tuple[List[int], List[int]]]:
     """get the unique excitation data
 
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 5a865cae..d8278cec 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -1,7 +1,6 @@
 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
@@ -10,7 +9,6 @@
 
 
 class SlaterPooling(nn.Module):
-
     """Applies a slater determinant pooling in the active space."""
 
     def __init__(
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index dd2580ef..1910b83d 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -1,6 +1,6 @@
 import torch
 import operator
-from typing import Union, Dict, Tuple
+from typing import Union, Dict
 from .slater_jastrow import SlaterJastrow
 from .jastrows.elec_elec.kernels.jastrow_kernel_electron_electron_base import (
     JastrowKernelElectronElectronBase,
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 8ac9b6c7..bb11ece5 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,5 +1,4 @@
 import unittest
-import numpy as np
 
 
 class BaseTestSolvers:
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
index bbf45046..94beb9b2 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 
 from qmctorch.scf import Molecule
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 a341ef84..3c9a2da4 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -2,7 +2,7 @@
 
 import torch
 from torch import nn
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 
 from qmctorch.scf import Molecule
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 4eed0c4a..af00a177 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 
 from qmctorch.scf import Molecule
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index 101c618e..34656571 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
index 573dc983..3d0c251f 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
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 63e454a7..4002ed2a 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,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable, grad
+from torch.autograd import Variable
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 3518f82b..877f052f 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -3,7 +3,6 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
     JastrowFactorElectronElectron,

From d75eb8ce96aa48e24d5eb258b7227aaf2ed167ab Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 3 Mar 2025 18:19:34 +0100
Subject: [PATCH 260/286] fix clip loss

---
 docs/example/optimization/h2.py |  2 +-
 qmctorch/solver/solver.py       |  3 ++-
 qmctorch/utils/torch_utils.py   | 12 +++++++-----
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 70f6fd28..0cad3b36 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -63,7 +63,7 @@
 # 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=True, clip_threshold=2,
                  resampling={'mode': 'update',
                              'resample_every': 1,
                              'nstep_update': 150,
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index be7f7bc4..ec6c245f 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -44,6 +44,7 @@ def configure(  # pylint: disable=too-many-arguments
         grad=None,
         ortho_mo=None,
         clip_loss=False,
+        clip_threshold=5,
         resampling=None,
     ):
         """Configure the solver
@@ -85,7 +86,7 @@ def configure(  # pylint: disable=too-many-arguments
 
         # get the loss
         if loss is not None:
-            self.loss = Loss(self.wf, method=loss, clip=clip_loss)
+            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
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index e392f343..423ff46a 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -167,7 +167,7 @@ def __next__(self):
 
 
 class Loss(nn.Module):
-    def __init__(self, wf, method="energy", clip=False):
+    def __init__(self, wf, method="energy", clip=False, clip_threshold=5):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -194,7 +194,7 @@ def __init__(self, wf, method="energy", clip=False):
 
         # number of +/- std for clipping
         # Excludes values + /- Nstd x std the mean of the eloc
-        self.clip_num_std = 5
+        self.clip_num_std = clip_threshold
 
         # select loss function
         self.loss_fn = {"energy": torch.mean, "variance": torch.var}[method]
@@ -251,9 +251,11 @@ def get_clipping_mask(self, local_energies):
         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)
+            zscore = torch.abs((local_energies - median) / std)    
+            mask = zscore < self.clip_num_std
+            # emax = median + self.clip_num_std * std
+            # emin = median - self.clip_num_std * std
+            # mask = (local_energies < emax) & (local_energies > emin)
         else:
             mask = torch.ones_like(local_energies).type(torch.bool)
 

From 564ba6f1cbcf8ea70f7bb5108e966656f17cd8f3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Mar 2025 11:00:43 +0100
Subject: [PATCH 261/286] fix clip for grd manual

---
 qmctorch/solver/solver.py     | 22 ++++++++++++++++++----
 qmctorch/utils/torch_utils.py |  3 ---
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index ec6c245f..9cf637a7 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -373,8 +373,11 @@ def evaluate_grad_manual(self, lpos):
             # Get the gradient of the total energy
             # dE/dk = < (dpsi/dk)/psi (E_L - <E_L >) >
 
-            # compute local energy and wf values
-            _, eloc = self.loss(lpos, no_grad=no_grad_eloc)
+            # 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)
 
@@ -382,8 +385,12 @@ def evaluate_grad_manual(self, lpos):
             weight = eloc.clone()
             weight -= torch.mean(eloc)
             weight /= psi.clone()
-            weight *= 2.0
-            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
             psi.backward(weight)
@@ -432,6 +439,13 @@ def evaluate_grad_manual_2(self, lpos):
             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)
 
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index 423ff46a..c488172c 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -253,9 +253,6 @@ def get_clipping_mask(self, local_energies):
             std = torch.std(local_energies)
             zscore = torch.abs((local_energies - median) / std)    
             mask = zscore < self.clip_num_std
-            # emax = median + self.clip_num_std * std
-            # emin = median - self.clip_num_std * std
-            # mask = (local_energies < emax) & (local_energies > emin)
         else:
             mask = torch.ones_like(local_energies).type(torch.bool)
 

From cf8e2f6d3e2dafefc2f44e8a12726e07b67a06a5 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Mar 2025 16:23:53 +0100
Subject: [PATCH 262/286] Revert "ruff and black"

This reverts commit 6fbb4af8c7c3140828552b65be42b74680f0fe47.
---
 docs/conf.py                                  |   1 +
 docs/example/ase/h2.py                        |   4 +-
 docs/example/backflow/backflow.py             |   1 +
 docs/example/graph/jast_graph.py              |   2 +
 docs/example/optimization/h2.py               |   3 +-
 docs/notebooks/combining_jastrow.ipynb        |  13 +-
 docs/notebooks/correlation.ipynb              |  31 ++--
 docs/notebooks/create_backflow.ipynb          |  15 +-
 docs/notebooks/create_jastrow.ipynb           |  25 +---
 docs/notebooks/geoopt.ipynb                   |  41 ++----
 docs/notebooks/gpu.ipynb                      |  22 ++-
 docs/notebooks/horovod.ipynb                  |  54 +++----
 docs/notebooks/molecule.ipynb                 |  18 +--
 docs/notebooks/sampling.ipynb                 |  49 +++----
 docs/notebooks/wfopt.ipynb                    |  44 +++---
 h5x/baseimport.py                             |   8 ++
 notebooks/NeuralJastrow.ipynb                 | 121 +++++++---------
 notebooks/test.ipynb                          | 132 ++++++++----------
 qmctorch/__init__.py                          |   1 -
 qmctorch/ase/ase.py                           |   5 +-
 qmctorch/ase/optimizer/torch_optim.py         |   4 +-
 qmctorch/sampler/metropolis_all_elec.py       |   2 +-
 .../sampler/metropolis_hasting_all_elec.py    |   2 +-
 qmctorch/sampler/pints_sampler.py             |   2 +-
 qmctorch/solver/solver.py                     |   3 +-
 qmctorch/solver/solver_base.py                |   2 +-
 qmctorch/solver/solver_mpi.py                 |   2 +-
 qmctorch/utils/torch_utils.py                 |   2 +-
 .../distance/electron_nuclei_distance.py      |   2 +-
 .../kernels/pade_jastrow_polynomial_kernel.py |   2 +-
 ...jastrow_factor_electron_electron_nuclei.py |   2 +-
 .../backflow/kernels/backflow_kernel_base.py  |   2 +-
 .../backflow/kernels/backflow_kernel_exp.py   |   1 +
 .../kernels/backflow_kernel_inverse.py        |   1 +
 .../backflow/kernels/backflow_kernel_rbf.py   |   1 +
 .../orbitals/spherical_harmonics.py           |  12 +-
 .../pooling/orbital_configurations.py         |   4 +-
 .../wavefunction/pooling/slater_pooling.py    |   2 +
 .../slater_orbital_dependent_jastrow.py       |   2 +-
 tests/solver/test_base_solver.py              |   1 +
 .../test_backflow_kernel_exp_pyscf.py         |   2 +-
 .../test_backflow_kernel_generic_pyscf.py     |   2 +-
 .../test_backflow_kernel_inverse_pyscf.py     |   2 +-
 .../test_backflow_transformation_pyscf.py     |   2 +-
 .../test_backflow_transformation_rbf_pyscf.py |   2 +-
 ...dependent_backflow_transformation_pyscf.py |   2 +-
 .../test_slater_orbital_dependent_jastrow.py  |   1 +
 47 files changed, 284 insertions(+), 370 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 741bab07..1499e898 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,6 +19,7 @@
 #
 import os
 import sys
+from unittest.mock import MagicMock
 
 
 # MOCK_CLASSES = ['torch.nn.Module']
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index f1cfbc40..7032544b 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,9 +1,11 @@
 from qmctorch.ase import QMCTorch
+from qmctorch.ase.optimizer import TorchOptimizer
 from ase import Atoms
-from ase.optimize import FIRE
+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)
diff --git a/docs/example/backflow/backflow.py b/docs/example/backflow/backflow.py
index 836fca3a..48a8144b 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -1,3 +1,4 @@
+from qmctorch.wavefunction.jastrows.elec_elec.kernels import FullyConnectedJastrowKernel
 import torch
 from torch import nn
 
diff --git a/docs/example/graph/jast_graph.py b/docs/example/graph/jast_graph.py
index 754e9ecf..0fee14d4 100644
--- a/docs/example/graph/jast_graph.py
+++ b/docs/example/graph/jast_graph.py
@@ -1,8 +1,10 @@
 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
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 903c2bc0..41354569 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -5,8 +5,9 @@
 from qmctorch.scf import Molecule
 
 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.plot_data import plot_energy, plot_data
 from qmctorch.wavefunction.slater_jastrow import SlaterJastrow
 from qmctorch.wavefunction.jastrows.elec_elec import JastrowFactor, PadeJastrowKernel
 
diff --git a/docs/notebooks/combining_jastrow.ipynb b/docs/notebooks/combining_jastrow.ipynb
index 2a80d778..2861fd47 100644
--- a/docs/notebooks/combining_jastrow.ipynb
+++ b/docs/notebooks/combining_jastrow.ipynb
@@ -85,12 +85,11 @@
    ],
    "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,\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)"
    ]
   },
   {
@@ -171,7 +170,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec * 3)\n",
+    "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
    ]
   }
diff --git a/docs/notebooks/correlation.ipynb b/docs/notebooks/correlation.ipynb
index 0f6cc70c..876ee1eb 100644
--- a/docs/notebooks/correlation.ipynb
+++ b/docs/notebooks/correlation.ipynb
@@ -33,11 +33,8 @@
     "from qmctorch.sampler import Metropolis\n",
     "from qmctorch.solver import Solver\n",
     "from qmctorch.utils import set_torch_double_precision\n",
-    "from qmctorch.utils.plot_data import plot_blocking_energy\n",
-    "from qmctorch.utils.plot_data import (\n",
-    "    plot_correlation_coefficient,\n",
-    "    plot_integrated_autocorrelation_time,\n",
-    ")"
+    "from qmctorch.utils.plot_data import blocking, plot_blocking_energy\n",
+    "from qmctorch.utils.plot_data  import plot_correlation_coefficient, plot_integrated_autocorrelation_time"
    ]
   },
   {
@@ -77,9 +74,7 @@
    ],
    "source": [
     "set_torch_double_precision()\n",
-    "mol = Molecule(\n",
-    "    atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\", redo_scf=True\n",
-    ")"
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -105,7 +100,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs=\"ground_state\")"
+    "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
   },
   {
@@ -139,17 +134,11 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(\n",
-    "    nwalkers=100,\n",
-    "    nstep=500,\n",
-    "    step_size=0.25,\n",
-    "    nelec=wf.nelec,\n",
-    "    ndim=wf.ndim,\n",
-    "    init=mol.domain(\"normal\"),\n",
-    "    ntherm=0,\n",
-    "    ndecor=1,\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    ")"
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                    nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                    init=mol.domain('normal'),\n",
+    "                    ntherm=0, ndecor=1,\n",
+    "                    move={'type': 'all-elec', 'proba': 'normal'})"
    ]
   },
   {
@@ -329,7 +318,7 @@
     }
    ],
    "source": [
-    "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers=\"mean\")"
+    "eb = plot_blocking_energy(obs.local_energy, block_size=100, walkers='mean')"
    ]
   },
   {
diff --git a/docs/notebooks/create_backflow.ipynb b/docs/notebooks/create_backflow.ipynb
index 84c3e1d9..43f8b237 100644
--- a/docs/notebooks/create_backflow.ipynb
+++ b/docs/notebooks/create_backflow.ipynb
@@ -47,7 +47,7 @@
     "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)"
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -65,18 +65,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from torch import nn\n",
-    "\n",
-    "\n",
+    "from torch import nn \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",
-    "\n",
     "    def _backflow_kernel(self, x):\n",
     "        original_shape = x.shape\n",
-    "        x = x.reshape(-1, 1)\n",
+    "        x = x.reshape(-1,1)\n",
     "        x = self.fc2(self.fc1(x))\n",
     "        return x.reshape(*original_shape)"
    ]
@@ -95,9 +92,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "backflow = BackFlowTransformation(\n",
-    "    mol, MyBackflowKernel, backflow_kernel_kwargs={\"size\": 8}\n",
-    ")"
+    "backflow = BackFlowTransformation(mol, MyBackflowKernel, backflow_kernel_kwargs={'size': 8})"
    ]
   },
   {
@@ -157,7 +152,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec * 3)\n",
+    "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
    ]
   }
diff --git a/docs/notebooks/create_jastrow.ipynb b/docs/notebooks/create_jastrow.ipynb
index 76592eb9..de55cc49 100644
--- a/docs/notebooks/create_jastrow.ipynb
+++ b/docs/notebooks/create_jastrow.ipynb
@@ -31,12 +31,8 @@
     "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 (\n",
-    "    JastrowFactorElectronElectron,\n",
-    ")\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
-    "    JastrowKernelElectronElectronBase,\n",
-    ")"
+    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import JastrowFactorElectronElectron\n",
+    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import JastrowKernelElectronElectronBase"
    ]
   },
   {
@@ -65,9 +61,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(\n",
-    "    atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\", redo_scf=True\n",
-    ")"
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -85,18 +79,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from torch import nn\n",
-    "\n",
-    "\n",
+    "from torch import nn \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",
     "        self.fc2 = nn.Linear(size, 1, bias=False)\n",
-    "\n",
     "    def forward(self, x):\n",
     "        nbatch, npair = x.shape\n",
-    "        x = x.reshape(-1, 1)\n",
+    "        x = x.reshape(-1,1)\n",
     "        x = self.fc2(self.fc1(x))\n",
     "        return x.reshape(nbatch, npair)"
    ]
@@ -127,9 +118,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "jastrow = JastrowFactorElectronElectron(\n",
-    "    mol, MyJastrowKernel, kernel_kwargs={\"size\": 64}\n",
-    ")"
+    "jastrow = JastrowFactorElectronElectron(mol, MyJastrowKernel, kernel_kwargs={'size': 64})"
    ]
   },
   {
@@ -189,7 +178,7 @@
     }
    ],
    "source": [
-    "pos = torch.rand(10, wf.nelec * 3)\n",
+    "pos = torch.rand(10, wf.nelec*3)\n",
     "print(wf(pos))"
    ]
   },
diff --git a/docs/notebooks/geoopt.ipynb b/docs/notebooks/geoopt.ipynb
index 2ed0f642..f47d6c37 100644
--- a/docs/notebooks/geoopt.ipynb
+++ b/docs/notebooks/geoopt.ipynb
@@ -35,7 +35,6 @@
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.utils.plot_data import plot_energy\n",
     "from qmctorch.utils import set_torch_double_precision\n",
-    "\n",
     "set_torch_double_precision()"
    ]
   },
@@ -71,13 +70,8 @@
     }
    ],
    "source": [
-    "mol = Molecule(\n",
-    "    atom=\"H 0. 0. -0.5; H 0. 0. 0.5\",\n",
-    "    unit=\"bohr\",\n",
-    "    calculator=\"pyscf\",\n",
-    "    basis=\"sto-3g\",\n",
-    "    redo_scf=True,\n",
-    ")"
+    "mol = Molecule(atom = 'H 0. 0. -0.5; H 0. 0. 0.5', unit='bohr', \n",
+    "               calculator='pyscf', basis='sto-3g', redo_scf=True)"
    ]
   },
   {
@@ -132,20 +126,14 @@
    ],
    "source": [
     "# wave function with only the ground state determinant\n",
-    "wf = SlaterJastrow(mol, configs=\"single_double(2,2)\").gto2sto()\n",
+    "wf = SlaterJastrow(mol, configs='single_double(2,2)').gto2sto()\n",
     "\n",
     "# sampler\n",
-    "sampler = Metropolis(\n",
-    "    nwalkers=1000,\n",
-    "    nstep=200,\n",
-    "    step_size=0.5,\n",
-    "    nelec=wf.nelec,\n",
-    "    ndim=wf.ndim,\n",
-    "    ntherm=-1,\n",
-    "    ndecor=100,\n",
-    "    init=mol.domain(\"normal\"),\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    ")\n",
+    "sampler = Metropolis(nwalkers=1000, nstep=200, step_size=0.5,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     ntherm=-1, ndecor=100,\n",
+    "                     init=mol.domain('normal'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})\n",
     "# optimizer\n",
     "opt = Adam(wf.parameters(), lr=0.005)\n",
     "\n",
@@ -171,10 +159,11 @@
     }
    ],
    "source": [
-    "solver = Solver(wf=wf, sampler=sampler, optimizer=opt, scheduler=None)\n",
-    "solver.configure(\n",
-    "    loss=\"energy\", grad=\"auto\", track=[\"local_energy\", \"geometry\"], freeze=[\"ao\"]\n",
-    ")"
+    "solver = Solver(wf=wf,\n",
+    "                       sampler=sampler,\n",
+    "                       optimizer=opt,\n",
+    "                       scheduler=None)\n",
+    "solver.configure(loss='energy', grad='auto', track=['local_energy','geometry'], freeze = ['ao'])"
    ]
   },
   {
@@ -463,7 +452,7 @@
    ],
    "source": [
     "solver.set_params_requires_grad(wf_params=False, geo_params=True)\n",
-    "obs = solver.run(50)"
+    "obs = solver.run(50)\n"
    ]
   },
   {
@@ -472,7 +461,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.save_traj(\"h2_traj.xyz\", obs)"
+    "solver.save_traj('h2_traj.xyz', obs)"
    ]
   },
   {
diff --git a/docs/notebooks/gpu.ipynb b/docs/notebooks/gpu.ipynb
index 8f9afe4d..3f49e7fc 100644
--- a/docs/notebooks/gpu.ipynb
+++ b/docs/notebooks/gpu.ipynb
@@ -24,11 +24,12 @@
    "outputs": [],
    "source": [
     "import torch\n",
+    "from torch import optim\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
-    "\n",
-    "mol = Molecule(atom=\"H 0. 0. 0; H 0. 0. 1.\", unit=\"bohr\", redo_scf=True)"
+    "from qmctorch.utils import (plot_energy, plot_data)\n",
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -48,18 +49,13 @@
    "source": [
     "if torch.cuda.is_available():\n",
     "    wf = SlaterJastrow(mol, cuda=True)\n",
-    "    sampler = Metropolis(\n",
-    "        nwalkers=100,\n",
-    "        nstep=500,\n",
-    "        step_size=0.25,\n",
-    "        nelec=wf.nelec,\n",
-    "        ndim=wf.ndim,\n",
-    "        init=mol.domain(\"atomic\"),\n",
-    "        move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    "        cuda=True,\n",
-    "    )\n",
+    "    sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
+    "                     cuda=True)\n",
     "else:\n",
-    "    print(\"CUDA not available, install torch with cuda support to proceed\")"
+    "    print('CUDA not available, install torch with cuda support to proceed')"
    ]
   }
  ],
diff --git a/docs/notebooks/horovod.ipynb b/docs/notebooks/horovod.ipynb
index 0527bc33..a3e49937 100644
--- a/docs/notebooks/horovod.ipynb
+++ b/docs/notebooks/horovod.ipynb
@@ -25,10 +25,10 @@
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
+    "from qmctorch.utils import (plot_energy, plot_data)\n",
     "from qmctorch.utils import set_torch_double_precision\n",
-    "\n",
     "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.', unit='bohr', redo_scf=True)"
    ]
   },
   {
@@ -54,16 +54,11 @@
    "outputs": [],
    "source": [
     "wf = SlaterJastrow(mol, cuda=use_gpu).gto2sto()\n",
-    "sampler = Metropolis(\n",
-    "    nwalkers=100,\n",
-    "    nstep=500,\n",
-    "    step_size=0.25,\n",
-    "    nelec=wf.nelec,\n",
-    "    ndim=wf.ndim,\n",
-    "    init=mol.domain(\"atomic\"),\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    "    cuda=use_gpu,\n",
-    ")"
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'},\n",
+    "                     cuda=use_gpu)"
    ]
   },
   {
@@ -72,13 +67,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "lr_dict = [\n",
-    "    {\"params\": wf.jastrow.parameters(), \"lr\": 3e-3},\n",
-    "    {\"params\": wf.ao.parameters(), \"lr\": 1e-6},\n",
-    "    {\"params\": wf.mo.parameters(), \"lr\": 1e-3},\n",
-    "    {\"params\": wf.fc.parameters(), \"lr\": 2e-3},\n",
-    "]\n",
-    "opt = optim.Adam(lr_dict, lr=1e-3)"
+    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},\n",
+    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
+    "           {'params': wf.mo.parameters(), 'lr': 1E-3},\n",
+    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
+    "opt = optim.Adam(lr_dict, lr=1E-3)"
    ]
   },
   {
@@ -101,8 +94,10 @@
     "hvd.init()\n",
     "if torch.cuda.is_available():\n",
     "    torch.cuda.set_device(hvd.rank())\n",
-    "\n",
-    "solver = SolverMPI(wf=wf, sampler=sampler, optimizer=opt, rank=hvd.rank())"
+    "    \n",
+    "solver = SolverMPI(wf=wf, sampler=sampler,\n",
+    "                                    optimizer=opt,\n",
+    "                                    rank=hvd.rank())"
    ]
   },
   {
@@ -111,18 +106,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(\n",
-    "    track=[\"local_energy\"],\n",
-    "    freeze=[\"ao\", \"mo\"],\n",
-    "    loss=\"energy\",\n",
-    "    grad=\"auto\",\n",
-    "    ortho_mo=False,\n",
-    "    clip_loss=False,\n",
-    "    resampling={\"mode\": \"update\", \"resample_every\": 1, \"nstep_update\": 50},\n",
-    ")\n",
+    "solver.configure(track=['local_energy'], freeze=['ao', 'mo'],\n",
+    "                loss='energy', grad='auto',\n",
+    "                ortho_mo=False, clip_loss=False,\n",
+    "                resampling={'mode': 'update',\n",
+    "                            'resample_every': 1,\n",
+    "                            'nstep_update': 50})\n",
     "\n",
     "# optimize the wave function\n",
-    "obs = solver.run(5)"
+    "obs = solver.run(5)\n"
    ]
   },
   {
diff --git a/docs/notebooks/molecule.ipynb b/docs/notebooks/molecule.ipynb
index c114a785..99710989 100644
--- a/docs/notebooks/molecule.ipynb
+++ b/docs/notebooks/molecule.ipynb
@@ -79,7 +79,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom=\"H 0. 0. 0; H 0. 0. 1.\", calculator=\"pyscf\", unit=\"bohr\")"
+    "mol = Molecule(atom = 'H 0. 0. 0; H 0. 0. 1.', calculator='pyscf', unit='bohr')"
    ]
   },
   {
@@ -123,7 +123,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(atom=\"h2.xyz\", unit=\"bohr\", calculator=\"pyscf\", redo_scf=True)"
+    "mol = Molecule(atom='h2.xyz', unit='bohr', calculator='pyscf', redo_scf=True)"
    ]
   },
   {
@@ -177,13 +177,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(\n",
-    "    atom=\"H 0. 0. 0; H 0. 0. 1.\",\n",
-    "    unit=\"bohr\",\n",
-    "    calculator=\"pyscf\",\n",
-    "    basis=\"sto-6g\",\n",
-    "    redo_scf=True,\n",
-    ")"
+    "mol = Molecule(atom='H 0. 0. 0; H 0. 0. 1.', unit='bohr', calculator='pyscf', basis='sto-6g', redo_scf=True)"
    ]
   },
   {
@@ -241,9 +235,7 @@
    ],
    "source": [
     "try:\n",
-    "    mol = Molecule(\n",
-    "        atom=\"H 0. 0. 0; H 0. 0. 1.\", unit=\"bohr\", calculator=\"adf\", basis=\"dzp\"\n",
-    "    )\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)"
    ]
@@ -296,7 +288,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(load=\"./hdf5/LiH_adf_dz.hdf5\")"
+    "mol = Molecule(load='./hdf5/LiH_adf_dz.hdf5')"
    ]
   }
  ],
diff --git a/docs/notebooks/sampling.ipynb b/docs/notebooks/sampling.ipynb
index e20ce865..d1b83cfb 100644
--- a/docs/notebooks/sampling.ipynb
+++ b/docs/notebooks/sampling.ipynb
@@ -27,7 +27,8 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
+    "import numpy as np \n",
+    "import matplotlib.pyplot as plt \n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
     "from qmctorch.sampler import Metropolis\n",
@@ -77,9 +78,8 @@
    ],
    "source": [
     "# define the molecule\n",
-    "mol = Molecule(\n",
-    "    atom=\"water.xyz\", unit=\"angs\", calculator=\"pyscf\", basis=\"sto-3g\", name=\"water\"\n",
-    ")"
+    "mol = Molecule(atom='water.xyz', unit='angs',\n",
+    "               calculator='pyscf', basis='sto-3g', name='water')"
    ]
   },
   {
@@ -117,7 +117,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs=\"ground_state\")"
+    "wf = SlaterJastrow(mol, configs='ground_state')"
    ]
   },
   {
@@ -151,15 +151,10 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(\n",
-    "    nwalkers=100,\n",
-    "    nstep=500,\n",
-    "    step_size=0.25,\n",
-    "    nelec=wf.nelec,\n",
-    "    ndim=wf.ndim,\n",
-    "    init=mol.domain(\"atomic\"),\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    ")"
+    "sampler = Metropolis(nwalkers=100, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
    ]
   },
   {
@@ -250,8 +245,8 @@
    ],
    "source": [
     "pos = sampler(wf.pdf)\n",
-    "pos = pos.reshape(100, 10, 3).cpu().detach().numpy()\n",
-    "plt.scatter(pos[:, :, 0], pos[:, :, 1], s=0.5)"
+    "pos = pos.reshape(100,10,3).cpu().detach().numpy()\n",
+    "plt.scatter(pos[:,:,0],pos[:,:,1],s=0.5)"
    ]
   },
   {
@@ -286,17 +281,11 @@
     }
    ],
    "source": [
-    "sampler_singlewalker = Metropolis(\n",
-    "    nwalkers=1,\n",
-    "    nstep=500,\n",
-    "    step_size=0.25,\n",
-    "    nelec=wf.nelec,\n",
-    "    ndim=wf.ndim,\n",
-    "    ntherm=0,\n",
-    "    ndecor=1,\n",
-    "    init=mol.domain(\"atomic\"),\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    ")"
+    "sampler_singlewalker = Metropolis(nwalkers=1, nstep=500, step_size=0.25,\n",
+    "                     nelec=wf.nelec, ndim=wf.ndim,\n",
+    "                     ntherm=0, ndecor=1,\n",
+    "                     init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
    ]
   },
   {
@@ -359,8 +348,8 @@
    ],
    "source": [
     "pos = sampler_singlewalker(wf.pdf)\n",
-    "pos = pos.reshape(-1, 10, 3).detach().numpy()\n",
-    "plt.plot(pos[:, :, 0], pos[:, :, 1], marker=\"o\", ls=\"--\")"
+    "pos = pos.reshape(-1,10,3).detach().numpy()\n",
+    "plt.plot(pos[:,:,0], pos[:,:,1], marker=\"o\", ls='--')"
    ]
   },
   {
@@ -519,7 +508,7 @@
    "source": [
     "pos = solver.sampler(solver.wf.pdf)\n",
     "obs = solver.sampling_traj(pos)\n",
-    "plot_walkers_traj(obs.local_energy, walkers=\"mean\")"
+    "plot_walkers_traj(obs.local_energy, walkers='mean')"
    ]
   }
  ],
diff --git a/docs/notebooks/wfopt.ipynb b/docs/notebooks/wfopt.ipynb
index 34745df4..214b5a9c 100644
--- a/docs/notebooks/wfopt.ipynb
+++ b/docs/notebooks/wfopt.ipynb
@@ -34,7 +34,6 @@
     "from qmctorch.sampler import Metropolis\n",
     "from qmctorch.utils import set_torch_double_precision\n",
     "from qmctorch.utils.plot_data import plot_energy\n",
-    "\n",
     "set_torch_double_precision()"
    ]
   },
@@ -64,7 +63,7 @@
     }
    ],
    "source": [
-    "mol = Molecule(load=\"./hdf5/H2_adf_dzp.hdf5\")"
+    "mol = Molecule(load='./hdf5/H2_adf_dzp.hdf5')"
    ]
   },
   {
@@ -99,7 +98,7 @@
     }
    ],
    "source": [
-    "wf = SlaterJastrow(mol, configs=\"single_double(2,2)\")"
+    "wf = SlaterJastrow(mol, configs='single_double(2,2)')"
    ]
   },
   {
@@ -134,16 +133,11 @@
     }
    ],
    "source": [
-    "sampler = Metropolis(\n",
-    "    nwalkers=5000,\n",
-    "    nstep=200,\n",
-    "    step_size=0.2,\n",
-    "    ntherm=-1,\n",
-    "    ndecor=100,\n",
-    "    nelec=wf.nelec,\n",
-    "    init=mol.domain(\"atomic\"),\n",
-    "    move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    ")"
+    "sampler = Metropolis(nwalkers=5000,\n",
+    "                     nstep=200, step_size=0.2,\n",
+    "                     ntherm=-1, ndecor=100,\n",
+    "                     nelec=wf.nelec, init=mol.domain('atomic'),\n",
+    "                     move={'type': 'all-elec', 'proba': 'normal'})"
    ]
   },
   {
@@ -160,13 +154,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "lr_dict = [\n",
-    "    {\"params\": wf.jastrow.parameters(), \"lr\": 1e-2},\n",
-    "    {\"params\": wf.ao.parameters(), \"lr\": 1e-6},\n",
-    "    {\"params\": wf.mo.parameters(), \"lr\": 2e-3},\n",
-    "    {\"params\": wf.fc.parameters(), \"lr\": 2e-3},\n",
-    "]\n",
-    "opt = optim.Adam(lr_dict, lr=1e-3)"
+    "lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},\n",
+    "           {'params': wf.ao.parameters(), 'lr': 1E-6},\n",
+    "           {'params': wf.mo.parameters(), 'lr': 2E-3},\n",
+    "           {'params': wf.fc.parameters(), 'lr': 2E-3}]\n",
+    "opt = optim.Adam(lr_dict, lr=1E-3)\n"
    ]
   },
   {
@@ -228,7 +220,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(track=[\"local_energy\", \"parameters\"])"
+    "solver.configure(track=['local_energy', 'parameters'])"
    ]
   },
   {
@@ -245,7 +237,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(freeze=[\"ao\"])"
+    "solver.configure(freeze=['ao'])"
    ]
   },
   {
@@ -261,7 +253,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(loss=\"energy\")"
+    "solver.configure(loss='energy')"
    ]
   },
   {
@@ -278,7 +270,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(grad=\"manual\")"
+    "solver.configure(grad='manual')"
    ]
   },
   {
@@ -295,7 +287,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "solver.configure(resampling={\"mode\": \"update\", \"resample_every\": 1, \"nstep_update\": 25})"
+    "solver.configure(resampling={'mode': 'update',\n",
+    "                            'resample_every': 1,\n",
+    "                            'nstep_update': 25})"
    ]
   },
   {
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 09411dff..9a1e941d 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,3 +1,11 @@
+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" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
diff --git a/notebooks/NeuralJastrow.ipynb b/notebooks/NeuralJastrow.ipynb
index c9f5f550..edb840e8 100644
--- a/notebooks/NeuralJastrow.ipynb
+++ b/notebooks/NeuralJastrow.ipynb
@@ -16,7 +16,9 @@
      ]
     }
    ],
-   "source": []
+   "source": [
+    "import qmctorch"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -61,9 +63,7 @@
    "outputs": [],
    "source": [
     "import torch\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
-    "    JastrowFactorElectronElectron,\n",
-    ")\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",
@@ -72,8 +72,9 @@
     "\n",
     "# define the jastrow factor\n",
     "jastrow = JastrowFactorElectronElectron(\n",
-    "    nup, ndown, PadeJastrowKernel, kernel_kwargs={\"w\": 0.1}\n",
-    ")\n",
+    "            nup, ndown,\n",
+    "            PadeJastrowKernel,\n",
+    "            kernel_kwargs={'w': 0.1})\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -101,9 +102,7 @@
    "outputs": [],
    "source": [
     "import torch\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (\n",
-    "    JastrowFactorElectronElectron,\n",
-    ")\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",
@@ -112,8 +111,9 @@
     "\n",
     "# define the jastrow factor\n",
     "jastrow = JastrowFactorElectronElectron(\n",
-    "    nup, ndown, FullyConnectedJastrowKernel, kernel_kwargs={\"size1\": 32, \"size2\": 64}\n",
-    ")\n",
+    "            nup, ndown,\n",
+    "            FullyConnectedJastrowKernel,\n",
+    "            kernel_kwargs={'size1': 32, 'size2': 64})\n",
     "\n",
     "# define random electronic positions\n",
     "nbatch = 10\n",
@@ -170,23 +170,20 @@
     "import torch\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
-    "    PadeJastrowKernel,\n",
-    "    FullyConnectedJastrowKernel,\n",
-    ")\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\", unit=\"bohr\", calculator=\"pyscf\", basis=\"sto-3g\"\n",
-    ")\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(\n",
-    "    mol,\n",
-    "    jastrow_kernel=PadeJastrowKernel,\n",
-    "    jastrow_kernel_kwargs={\"w\": 0.1},\n",
-    "    configs=\"single_double(2,2)\",\n",
-    ")\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",
@@ -225,23 +222,20 @@
     "import torch\n",
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
-    "    PadeJastrowKernel,\n",
-    "    FullyConnectedJastrowKernel,\n",
-    ")\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\", unit=\"bohr\", calculator=\"pyscf\", basis=\"sto-3g\"\n",
-    ")\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(\n",
-    "    mol,\n",
-    "    jastrow_kernel=FullyConnectedJastrowKernel,\n",
-    "    jastrow_kernel_kwargs={\"size1\": 32, \"size2\": 64},\n",
-    "    configs=\"single_double(2,2)\",\n",
-    ")\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",
@@ -268,18 +262,13 @@
    "source": [
     "from qmctorch.scf import Molecule\n",
     "from qmctorch.wavefunction import SlaterJastrow\n",
-    "from qmctorch.wavefunction.jastrows.elec_elec.kernels import (\n",
-    "    PadeJastrowKernel,\n",
-    "    FullyConnectedJastrowKernel,\n",
-    ")\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(\n",
-    "        atom=\"H 0 0 -0.69; H 0. 0. 0.69\", calculator=\"adf\", basis=\"dzp\", unit=\"bohr\"\n",
-    "    )\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",
@@ -291,45 +280,39 @@
     "    # 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(\n",
-    "        mol,\n",
-    "        jastrow_kernel=FullyConnectedJastrowKernel,\n",
-    "        jastrow_kernel_kwargs={\"size1\": 32, \"size2\": 64},\n",
-    "        configs=\"single_double(4,12)\",\n",
-    "    )\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(\n",
-    "        nwalkers=10000,\n",
-    "        nstep=2000,\n",
-    "        step_size=0.05,\n",
-    "        ntherm=-1,\n",
-    "        ndecor=100,\n",
-    "        nelec=wf.nelec,\n",
-    "        init=mol.domain(\"atomic\"),\n",
-    "        move={\"type\": \"all-elec\", \"proba\": \"normal\"},\n",
-    "        cuda=cuda,\n",
-    "    )\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 = [\n",
-    "        {\"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",
-    "    ]\n",
-    "    opt = optim.Adam(lr_dict, lr=1e-3)\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, optimizer=opt, scheduler=scheduler)\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",
+    "    solver.track_observable(['local_energy', 'parameters'])\n",
     "\n",
-    "    solver.configure_resampling(mode=\"update\", resample_every=1, nstep_update=100)\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)"
diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index 3ef64bf4..47f98cd7 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -1,4 +1,28 @@
 {
+ "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",
@@ -6,8 +30,8 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
      "output_type": "stream",
+     "name": "stdout",
      "text": [
       "INFO:QMCTorch|  ____    __  ______________             _\n",
       "INFO:QMCTorch| / __ \\  /  |/  / ___/_  __/__  ________/ /  \n",
@@ -31,14 +55,12 @@
    ],
    "source": [
     "from qmctorch.scf import Molecule\n",
-    "\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,\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)"
    ]
   },
   {
@@ -47,8 +69,8 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
      "output_type": "stream",
+     "name": "stderr",
      "text": [
       "Using backend: pytorch\n"
      ]
@@ -56,12 +78,8 @@
    ],
    "source": [
     "from qmctorch.wavefunction.orbitals.atomic_orbitals import AtomicOrbitals\n",
-    "from qmctorch.wavefunction.orbitals.atomic_orbitals_backflow import (\n",
-    "    AtomicOrbitalsBackFlow,\n",
-    ")\n",
-    "from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (\n",
-    "    BackFlowTransformation,\n",
-    ")\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",
@@ -72,25 +90,24 @@
    ]
   },
   {
+   "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",
-   "execution_count": 23,
    "metadata": {},
+   "execution_count": 23,
    "outputs": [
     {
-     "name": "stdout",
      "output_type": "stream",
+     "name": "stdout",
      "text": [
       "torch.Size([11, 4, 6, 3])\ntorch.Size([4, 11, 4, 6])\n"
      ]
     }
-   ],
-   "source": [
-    "import torch\n",
-    "\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)"
    ]
   },
   {
@@ -99,30 +116,27 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
      "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 (\n",
-    "    JastrowFactorElectronElectron,\n",
-    ")\n",
+    "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(mol, PadeJastrowKernel)\n",
+    "jastrow = JastrowFactorElectronElectron(\n",
+    "            mol, PadeJastrowKernel)\n",
     "\n",
-    "wf = SlaterJastrow(\n",
-    "    mol,\n",
-    "    kinetic=\"jacobi\",\n",
-    "    include_all_mo=True,\n",
-    "    configs=\"single_double(2,2)\",\n",
-    "    jastrow=jastrow,\n",
-    "    backflow=bf,\n",
-    ")"
+    "wf = SlaterJastrow(mol,\n",
+    "                                kinetic='jacobi',\n",
+    "                                include_all_mo=True,\n",
+    "                                configs='single_double(2,2)',\n",
+    "                                jastrow=jastrow,\n",
+    "                                backflow=bf)"
    ]
   },
   {
@@ -131,13 +145,14 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
      "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",
@@ -368,13 +383,12 @@
        "           -9.2339e-02]]]], grad_fn=<UnsafeViewBackward>)"
       ]
      },
-     "execution_count": 20,
      "metadata": {},
-     "output_type": "execute_result"
+     "execution_count": 20
     }
    ],
    "source": [
-    "wf.ao2mo(wf.ao(pos, 1))"
+    "wf.ao2mo(wf.ao(pos,1))"
    ]
   },
   {
@@ -383,13 +397,14 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
      "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",
@@ -405,9 +420,8 @@
        "        [ -1.5769]], grad_fn=<MulBackward0>)"
       ]
      },
-     "execution_count": 27,
      "metadata": {},
-     "output_type": "execute_result"
+     "execution_count": 27
     }
    ],
    "source": [
@@ -421,29 +435,5 @@
    "outputs": [],
    "source": []
   }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "7ce898621bfdc1ef835a37ba44cfccabe14bea8b663e0a8a268cd00c3f89209b"
-  },
-  "kernelspec": {
-   "display_name": "Python 3.8.0 64-bit ('qmctorch': conda)",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.0"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
+ ]
 }
\ No newline at end of file
diff --git a/qmctorch/__init__.py b/qmctorch/__init__.py
index 9dc5f942..a701e0b7 100644
--- a/qmctorch/__init__.py
+++ b/qmctorch/__init__.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 """Documentation about QMCTorch"""
-
 from .__version__ import __version__
 
 
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 8c7a649f..5ff3f0bd 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -1,4 +1,4 @@
-from ase.calculators.calculator import Calculator
+from ase.calculators.calculator import Calculator, all_changes
 from ase import Atoms
 import numpy as np
 import torch
@@ -15,6 +15,7 @@
 )
 from ..solver import Solver
 from ..sampler import Metropolis
+from .. import log
 
 
 class QMCTorch(Calculator):
@@ -26,7 +27,7 @@ def __init__(
         *,
         labels: list = None,
         atoms: Atoms = None,
-        **kwargs: dict,
+        **kwargs: dict
     ) -> None:
         """
         Initialize a QMCTorchCalculator object.
diff --git a/qmctorch/ase/optimizer/torch_optim.py b/qmctorch/ase/optimizer/torch_optim.py
index db49b06e..5f3c9fd0 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -1,4 +1,4 @@
-from typing import IO, Optional, Union
+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
@@ -8,6 +8,8 @@
 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):
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index 4a925d9d..b7a66c29 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -76,7 +76,7 @@ def log_data(self) -> None:
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor],
+        func: Callable[[torch.Tensor], torch.Tensor]
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the log of a function
 
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index a96de08f..584c3753 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -66,7 +66,7 @@ def log_data(self) -> None:
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor],
+        func: Callable[[torch.Tensor], torch.Tensor]
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of  a function
 
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index 5a27d2b1..befbe65b 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -115,7 +115,7 @@ def log_data(self):
 
     @staticmethod
     def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor],
+        func: Callable[[torch.Tensor], torch.Tensor]
     ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of a function
 
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 9bc86557..2b3b9fba 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -1,7 +1,8 @@
+from copy import deepcopy
 from time import time
 from tqdm import tqdm
 from types import SimpleNamespace
-from typing import Optional, Dict, List, Tuple, Any
+from typing import Optional, Dict, Union, List, Tuple, Any
 import torch
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 0d756195..9cc441d3 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -177,7 +177,7 @@ def store_observable(
         pos: torch.tensor,
         local_energy: Optional[torch.tensor] = None,
         ibatch: Optional[int] = None,
-        **kwargs,
+        **kwargs
     ):
         """store observale in the dictionary
 
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index c764f54e..d2836582 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -1,6 +1,6 @@
 from time import time
 from types import SimpleNamespace
-from typing import Optional
+from typing import Optional, Dict, Union, List, Tuple, Any
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
 
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index f485f6a6..c9cc8d25 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, ContextManager, Tuple
 import torch
 from torch import nn
 from torch.autograd import grad, Variable
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index da7f590b..93029b9b 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -1,6 +1,6 @@
 import torch
 from torch import nn
-from typing import Tuple, Union
+from typing import Optional, Tuple, Union
 from .scaling import (
     get_scaled_distance,
     get_der_scaled_distance,
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 2762c36b..79ef5b8d 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,6 +1,6 @@
 import torch
 from torch import nn
-from typing import Union
+from typing import Union, Optional
 from .....utils import register_extra_attributes
 from .jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 
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 7860aa2d..ab4eb1f8 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,7 +1,7 @@
 import torch
 from torch import nn
 from torch.autograd import Variable, grad
-from typing import Dict, Tuple, Union
+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
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 71e1dfea..22eb6243 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -1,7 +1,7 @@
 import torch
 from torch import nn
 from torch.autograd import grad
-from typing import Tuple, Union
+from typing import Tuple, List, Union
 from .....scf import Molecule
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index e7c063a6..db0e71c0 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -2,6 +2,7 @@
 from torch import nn
 
 from .....scf import Molecule
+from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
index 7238ca99..993faaa2 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_inverse.py
@@ -2,6 +2,7 @@
 from torch import nn
 
 from .....scf import Molecule
+from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
index 9a4cb7d8..44ae9889 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -3,6 +3,7 @@
 from torch.nn import functional as F
 
 from .....scf import Molecule
+from .....utils import register_extra_attributes
 from .backflow_kernel_base import BackFlowKernelBase
 
 
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 6f507779..0f2b42d4 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -519,11 +519,7 @@ def _spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
         c0 = 0.31539156525252005
         return (
             c0
-            * (
-                -(xyz[:, :, :, 0] ** 2)
-                - xyz[:, :, :, 1] ** 2
-                + 2 * xyz[:, :, :, 2] ** 2
-            )
+            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
             / r2
         )
     if m == 2:
@@ -558,11 +554,7 @@ def _nabla_spherical_harmonics_l2(xyz: torch.Tensor, m: int) -> torch.Tensor:
         return c0 * (
             (-2 * xyz[:, :, :, 0] - 2 * xyz[:, :, :, 1] + 4 * xyz[:, :, :, 2]) / r2
             - 2
-            * (
-                -(xyz[:, :, :, 0] ** 2)
-                - xyz[:, :, :, 1] ** 2
-                + 2 * xyz[:, :, :, 2] ** 2
-            )
+            * (-xyz[:, :, :, 0] ** 2 - xyz[:, :, :, 1] ** 2 + 2 * xyz[:, :, :, 2] ** 2)
             * xyz.sum(3)
             / r3
         )
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 9848c006..e7c891ec 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -308,7 +308,7 @@ def _append_excitations(
 
 
 def get_excitation(
-    configs: Tuple[torch.LongTensor, torch.LongTensor],
+    configs: Tuple[torch.LongTensor, torch.LongTensor]
 ) -> Tuple[List[List[List[int]]], List[List[List[int]]]]:
     """Get the excitation data
 
@@ -350,7 +350,7 @@ def get_excitation(
 
 
 def get_unique_excitation(
-    configs: Tuple[torch.LongTensor, torch.LongTensor],
+    configs: Tuple[torch.LongTensor, torch.LongTensor]
 ) -> Tuple[Tuple[List[List[int]], List[List[int]]], Tuple[List[int], List[int]]]:
     """get the unique excitation data
 
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index d8278cec..5a865cae 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -1,6 +1,7 @@
 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
@@ -9,6 +10,7 @@
 
 
 class SlaterPooling(nn.Module):
+
     """Applies a slater determinant pooling in the active space."""
 
     def __init__(
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index 1910b83d..dd2580ef 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -1,6 +1,6 @@
 import torch
 import operator
-from typing import Union, Dict
+from typing import Union, Dict, Tuple
 from .slater_jastrow import SlaterJastrow
 from .jastrows.elec_elec.kernels.jastrow_kernel_electron_electron_base import (
     JastrowKernelElectronElectronBase,
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index bb11ece5..8ac9b6c7 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,4 +1,5 @@
 import unittest
+import numpy as np
 
 
 class BaseTestSolvers:
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
index 94beb9b2..bbf45046 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 
 from qmctorch.scf import Molecule
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 3c9a2da4..a341ef84 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -2,7 +2,7 @@
 
 import torch
 from torch import nn
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 
 from qmctorch.scf import Molecule
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 af00a177..4eed0c4a 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 
 from qmctorch.scf import Molecule
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
index 34656571..101c618e 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
index 3d0c251f..573dc983 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -1,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
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 4002ed2a..63e454a7 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,7 +1,7 @@
 import unittest
 
 import torch
-from torch.autograd import Variable
+from torch.autograd import Variable, grad
 import numpy as np
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.backflow_transformation import (
diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 877f052f..3518f82b 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -3,6 +3,7 @@
 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.wavefunction.jastrows.elec_elec.jastrow_factor_electron_electron import (
     JastrowFactorElectronElectron,

From 65342db4e87610a8575237208c3d2dbd2cfba353 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Mar 2025 16:24:41 +0100
Subject: [PATCH 263/286] Revert "black"

This reverts commit 35370ad5a828aba3e9cee132c6f2e8647bb2f9fe.
---
 docs/conf.py                                  | 146 ++++----
 docs/example/ase/h2.py                        |  32 +-
 docs/example/ase/h2_cc.py                     |  12 +-
 docs/example/autocorrelation/h2.py            |  28 +-
 docs/example/backflow/backflow.py             |  27 +-
 docs/example/gpu/h2.py                        |  65 ++--
 docs/example/graph/h2.py                      |  70 ++--
 docs/example/graph/jast_graph.py              |  10 +-
 docs/example/horovod/h2.py                    |  69 ++--
 docs/example/optimization/h2.py               |  59 ++-
 docs/example/scf/scf.py                       |  26 +-
 docs/example/single_point/h2.py               |  26 +-
 docs/example/single_point/h2o_sampling.py     |  29 +-
 h5x/baseimport.py                             |  12 +-
 qmctorch/__version__.py                       |   2 +-
 qmctorch/ase/__init__.py                      |   2 +-
 qmctorch/ase/ase.py                           | 349 +++++++-----------
 qmctorch/ase/optimizer/__init__.py            |   2 +-
 qmctorch/ase/optimizer/torch_optim.py         |  62 ++--
 qmctorch/sampler/generalized_metropolis.py    |  17 +-
 qmctorch/sampler/hamiltonian.py               |  28 +-
 qmctorch/sampler/metropolis_all_elec.py       |   5 +-
 .../sampler/metropolis_hasting_all_elec.py    |   5 +-
 qmctorch/sampler/pints_sampler.py             |   6 +-
 qmctorch/sampler/proposal_kernels.py          |   3 +-
 qmctorch/sampler/sampler_base.py              |   4 +-
 .../state_dependent_normal_proposal.py        |   8 +-
 qmctorch/scf/calculator/adf.py                |  14 +-
 qmctorch/scf/molecule.py                      |   2 +-
 qmctorch/solver/loss.py                       |  17 +-
 qmctorch/solver/solver.py                     |  75 ++--
 qmctorch/solver/solver_base.py                |  46 +--
 qmctorch/solver/solver_mpi.py                 |  26 +-
 qmctorch/utils/algebra_utils.py               |   3 +-
 qmctorch/utils/constants.py                   |   2 +-
 qmctorch/utils/hdf5_utils.py                  |   1 -
 qmctorch/utils/interpolate.py                 |  38 +-
 qmctorch/utils/plot_data.py                   |  31 +-
 qmctorch/utils/provenance.py                  |  10 +-
 qmctorch/utils/stat_utils.py                  |   7 +-
 qmctorch/utils/torch_utils.py                 |  25 +-
 .../distance/electron_electron_distance.py    |  27 +-
 .../distance/electron_nuclei_distance.py      |   8 +-
 .../wavefunction/jastrows/distance/scaling.py |   8 +-
 .../jastrow_factor_electron_electron.py       |  27 +-
 .../jastrow_kernel_electron_electron_base.py  |   9 +-
 .../elec_elec/kernels/pade_jastrow_kernel.py  |   4 +-
 .../kernels/pade_jastrow_polynomial_kernel.py |  27 +-
 ...jastrow_factor_electron_electron_nuclei.py |  46 +--
 .../kernels/boys_handy_jastrow_kernel.py      |   9 +-
 .../kernels/fully_connected_jastrow_kernel.py |   4 +-
 ...ow_kernel_electron_electron_nuclei_base.py |   8 +-
 .../jastrow_factor_electron_nuclei.py         |  38 +-
 .../kernels/fully_connected_jastrow_kernel.py |   7 +-
 .../jastrow_kernel_electron_nuclei_base.py    |  13 +-
 .../kernels/pade_jastrow_kernel.py            |  10 +-
 .../wavefunction/jastrows/graph/__init__.py   |   2 +-
 .../jastrows/graph/elec_elec_graph.py         |   2 +-
 .../jastrows/graph/elec_nuc_graph.py          |   8 +-
 .../jastrows/graph/mgcn_jastrow.py            |  28 +-
 .../wavefunction/orbitals/atomic_orbitals.py  |  77 ++--
 .../orbitals/atomic_orbitals_backflow.py      |  53 ++-
 .../backflow/backflow_transformation.py       |  14 +-
 .../orbitals/backflow/kernels/__init__.py     |   2 +-
 .../backflow_kernel_autodiff_inverse.py       |   3 +-
 .../backflow/kernels/backflow_kernel_base.py  |  15 +-
 .../backflow/kernels/backflow_kernel_exp.py   |  11 +-
 .../backflow_kernel_fully_connected.py        |   3 +-
 .../kernels/backflow_kernel_power_sum.py      |   1 -
 .../backflow/kernels/backflow_kernel_rbf.py   |  57 +--
 .../kernels/backflow_kernel_square.py         |   1 -
 .../orbital_dependent_backflow_kernel.py      |  13 +-
 ...bital_dependent_backflow_transformation.py |  13 +-
 .../wavefunction/orbitals/norm_orbital.py     |  64 ++--
 .../wavefunction/orbitals/radial_functions.py |   4 +-
 .../orbitals/spherical_harmonics.py           |  10 +-
 .../pooling/orbital_configurations.py         |  32 +-
 .../wavefunction/pooling/orbital_projector.py |  59 ++-
 .../wavefunction/pooling/slater_pooling.py    |  79 ++--
 qmctorch/wavefunction/slater_jastrow.py       | 123 +++---
 .../slater_orbital_dependent_jastrow.py       |  26 +-
 qmctorch/wavefunction/wf_base.py              |  27 +-
 setup.py                                      |  82 ++--
 tests/ase/test_ase_calc.py                    |  39 +-
 tests/solver/test_base_solver.py              |  15 +-
 .../test_generic_jastrow_orbital.py           |  53 +--
 .../elec_elec/test_generic_jastrow.py         |   8 +-
 .../jastrows/elec_elec/test_pade_jastrow.py   |   8 +-
 .../elec_elec/test_pade_jastrow_polynom.py    |   8 +-
 .../elec_elec/test_scaled_pade_jastrow.py     |   8 +-
 .../test_scaled_pade_jastrow_polynom.py       |   8 +-
 .../test_three_body_jastrow_boys_handy.py     |   8 +-
 ...test_three_body_jastrow_fully_connected.py |   8 +-
 .../test_electron_nuclei_fully_connected.py   |   8 +-
 .../test_electron_nuclei_pade_jastrow.py      |   8 +-
 .../orbitals/backflow/test_backflow_base.py   |  23 +-
 .../test_backflow_kernel_exp_pyscf.py         |   6 +-
 .../test_backflow_kernel_generic_pyscf.py     |   5 +-
 .../test_backflow_kernel_inverse_pyscf.py     |   7 +-
 .../test_backflow_transformation_pyscf.py     |   4 +-
 .../test_backflow_transformation_rbf_pyscf.py |   3 +-
 ...dependent_backflow_transformation_pyscf.py |   5 +-
 .../orbitals/test_ao_derivatives_adf.py       |   1 -
 .../test_backflow_ao_derivatives_pyscf.py     |   1 -
 ...dependent_backflow_ao_derivatives_pyscf.py |   1 -
 .../test_compare_slaterjastrow_backflow.py    |   2 -
 ...laterjastrow_orbital_dependent_backflow.py |   1 -
 .../test_slater_orbital_dependent_jastrow.py  |   6 +-
 .../test_slatercombinedjastrow_backflow.py    |   1 -
 .../test_slaterjastrow_backflow.py            |   1 -
 ...laterjastrow_orbital_dependent_backflow.py |   1 -
 tests_hvd/test_h2_hvd.py                      |  55 ++-
 112 files changed, 1175 insertions(+), 1582 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 1499e898..96a423a5 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -59,33 +59,32 @@
 
 
 autodoc_mock_imports = [
-    "numpy",
-    "scipy",
-    "h5py",
-    "twiggy",
-    "mpi4py",
-    "scipy.signal",
-    "torch",
-    "torch.utils",
-    "torch.utils.data",
-    "matplotlib",
-    "matplotlib.pyplot",
-    "torch.autograd",
-    "torch.nn",
-    "torch.optim",
-    "torch.cuda",
-    "torch.distributions",
-    "mendeleev",
-    "pandas",
-    "pyscf",
-    "adf",
-    "scm",
-    "tqdm",
-    "ase",
-    "horovod",
-]
-
-sys.path.insert(0, os.path.abspath("../"))
+    'numpy',
+    'scipy',
+    'h5py',
+    'twiggy',
+    'mpi4py',
+    'scipy.signal',
+    'torch',
+    'torch.utils',
+    'torch.utils.data',
+    'matplotlib',
+    'matplotlib.pyplot',
+    'torch.autograd',
+    'torch.nn',
+    'torch.optim',
+    'torch.cuda',
+    'torch.distributions',
+    'mendeleev',
+    'pandas',
+    'pyscf',
+    'adf',
+    'scm',
+    'tqdm',
+    'ase',
+    'horovod']
+
+sys.path.insert(0, os.path.abspath('../'))
 
 
 # -- General configuration ------------------------------------------------
@@ -98,58 +97,58 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.doctest",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.todo",
-    "sphinx.ext.coverage",
-    "sphinx.ext.mathjax",
-    "sphinx.ext.ifconfig",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.viewcode",
-    "nbsphinx",
+    'sphinx.ext.autodoc',
+    'sphinx.ext.doctest',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.ifconfig',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'nbsphinx'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "QMCTorch"
-copyright = "2020, Nicolas Renaud"
-author = "Nicolas Renaud"
+project = 'QMCTorch'
+copyright = '2020, Nicolas Renaud'
+author = 'Nicolas Renaud'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = "0.1"
+version = '0.1'
 # The full version, including alpha/beta/rc tags.
-release = "0.1.0"
+release = '0.1.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = "en"
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+pygments_style = 'sphinx'
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -166,7 +165,7 @@
 # else:
 #     html_theme = 'classic'
 
-html_theme = "sphinx_rtd_theme"
+html_theme = 'sphinx_rtd_theme'
 html_logo = "./pics/qmctorch_white.png"
 
 # Theme options are theme-specific and customize the look and feel of a theme
@@ -181,7 +180,7 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
@@ -189,11 +188,11 @@
 # This is required for the alabaster theme
 # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
 html_sidebars = {
-    "**": [
-        "globaltoc.html",
-        "relations.html",  # needs 'show_related': True theme option to display
-        "sourcelink.html",
-        "searchbox.html",
+    '**': [
+        'globaltoc.html',
+        'relations.html',  # needs 'show_related': True theme option to display
+        'sourcelink.html',
+        'searchbox.html',
     ]
 }
 
@@ -201,7 +200,7 @@
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "QMCTorchdoc"
+htmlhelp_basename = 'QMCTorchdoc'
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -210,12 +209,15 @@
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
+
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
+
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
+
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -225,7 +227,8 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "QMCTorch.tex", "QMCTorch Documentation", "Nicolas Renaud", "manual"),
+    (master_doc, 'QMCTorch.tex', 'QMCTorch Documentation',
+     'Nicolas Renaud', 'manual'),
 ]
 
 
@@ -233,7 +236,10 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "qmctorch", "QMCTorch Documentation", [author], 1)]
+man_pages = [
+    (master_doc, 'qmctorch', 'QMCTorch Documentation',
+     [author], 1)
+]
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -242,25 +248,19 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
-        master_doc,
-        "QMCTorch",
-        "QMCTorch Documentation",
-        author,
-        "QMCTorch",
-        "One line description of project.",
-        "Miscellaneous",
-    ),
+    (master_doc, 'QMCTorch', 'QMCTorch Documentation',
+     author, 'QMCTorch', 'One line description of project.',
+     'Miscellaneous'),
 ]
 
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {
-    "python": ("https://docs.python.org/", None),
-    "numpy": ("http://docs.scipy.org/doc/numpy/", None),
-    "pytorch": ("http://pytorch.org/docs/1.4.0/", None),
+    'python': ('https://docs.python.org/', None),
+    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
+    'pytorch': ('http://pytorch.org/docs/1.4.0/', None),
 }
 
-autoclass_content = "init"
-autodoc_member_order = "bysource"
+autoclass_content = 'init'
+autodoc_member_order = 'bysource'
 nbsphinx_allow_errors = True
-nbsphinx_execute = "never"
+nbsphinx_execute = 'never'
\ No newline at end of file
diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 7032544b..b367b48c 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,6 +1,6 @@
-from qmctorch.ase import QMCTorch
+from qmctorch.ase import QMCTorch     
 from qmctorch.ase.optimizer import TorchOptimizer
-from ase import Atoms
+from ase import Atoms 
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
 import torch
@@ -11,24 +11,24 @@
 np.random.seed(0)
 
 d = 0.70
-h2 = Atoms("H2", positions=[(0, 0, -d / 2), (0, 0, d / 2)])
+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"
+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,2)"
+h2.calc.wf_options.configs = 'single_double(2,2)'
 h2.calc.wf_options.orthogonalize_mo = False
 # h2.calc.wf_options.gto2sto = True
-h2.calc.wf_options.jastrow.kernel_kwargs = {"w": 1.0}
+h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
 
 # sampler options
 h2.calc.sampler_options.nwalkers = 100
-h2.calc.sampler_options.nstep = 5000
+h2.calc.sampler_options.nstep  = 5000
 h2.calc.sampler_options.step_size = 0.5
 h2.calc.sampler_options.ntherm = 4000
 h2.calc.sampler_options.ndecor = 10
@@ -37,10 +37,10 @@
 h2.calc.solver_options.freeze = []
 h2.calc.solver_options.niter = 10
 h2.calc.solver_options.tqdm = True
-h2.calc.solver_options.grad = "manual"
+h2.calc.solver_options.grad = 'manual'
 
 # options for the resampling
-h2.calc.solver_options.resampling.mode = "update"
+h2.calc.solver_options.resampling.mode = 'update'
 h2.calc.solver_options.resampling.resample_every = 1
 h2.calc.solver_options.resampling.ntherm_update = 100
 
@@ -48,11 +48,11 @@
 h2.calc.initialize()
 
 # use torch optim for the optimization
-# dyn = TorchOptimizer(h2,
-#                      trajectory='traj.xyz',
-#                      nepoch_wf_init=50,
-#                      nepoch_wf_update=15,
+# dyn = TorchOptimizer(h2, 
+#                      trajectory='traj.xyz', 
+#                      nepoch_wf_init=50, 
+#                      nepoch_wf_update=15, 
 #                      tqdm=True)
-dyn = FIRE(h2, trajectory="traj.xyz")
+dyn = FIRE(h2, trajectory='traj.xyz')
 dyn.run(fmax=0.005, steps=5)
-write("final.xyz", h2)
+write('final.xyz',h2)
diff --git a/docs/example/ase/h2_cc.py b/docs/example/ase/h2_cc.py
index 0cb59712..c0011484 100644
--- a/docs/example/ase/h2_cc.py
+++ b/docs/example/ase/h2_cc.py
@@ -1,16 +1,16 @@
 from pyscf import gto, scf, cc
 import numpy as np
-import matplotlib.pyplot as plt
+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)
+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)
+    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()
+plt.show()
\ No newline at end of file
diff --git a/docs/example/autocorrelation/h2.py b/docs/example/autocorrelation/h2.py
index f5e601f2..6d0e17dd 100644
--- a/docs/example/autocorrelation/h2.py
+++ b/docs/example/autocorrelation/h2.py
@@ -4,26 +4,26 @@
 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.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"
-)
+    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)")
+wf = SlaterJastrow(mol, kinetic='auto',
+                   jastrow=jastrow,
+                   configs='single(2,2)')
 
 # sampler
 sampler = Metropolis(
@@ -34,9 +34,10 @@
     step_size=0.5,
     ndim=wf.ndim,
     nelec=wf.nelec,
-    init=mol.domain("normal"),
-    move={"type": "all-elec", "proba": "normal"},
-)
+    init=mol.domain('normal'),
+    move={
+        'type': 'all-elec',
+        'proba': 'normal'})
 
 opt = optim.Adam(wf.parameters(), lr=0.01)
 
@@ -46,6 +47,7 @@
 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'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 48a8144b..d557ef25 100644
--- a/docs/example/backflow/backflow.py
+++ b/docs/example/backflow/backflow.py
@@ -13,6 +13,7 @@
 
 
 class MyBackflow(BackFlowKernelBase):
+
     def __init__(self, mol, cuda, size=16):
         super().__init__(mol, cuda)
         self.fc1 = nn.Linear(1, size, bias=False)
@@ -26,28 +27,20 @@ def _backflow_kernel(self, x):
 
 
 # define the molecule
-mol = Molecule(
-    atom="Li 0. 0. 0.; H 3.14 0. 0.",
-    unit="angs",
-    calculator="pyscf",
-    basis="sto-3g",
-    name="LiH",
-)
+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})
+backflow = BackFlowTransformation(mol, MyBackflow, {'size': 64})
 
 # define the wave function
-wf = SlaterJastrow(
-    mol,
-    kinetic="jacobi",
-    jastrow=jastrow,
-    backflow=backflow,
-    configs="single_double(2,2)",
-)
-
-pos = torch.rand(10, wf.nelec * 3)
+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 fcbaf1ef..755441ff 100644
--- a/docs/example/gpu/h2.py
+++ b/docs/example/gpu/h2.py
@@ -6,7 +6,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import plot_energy, plot_data
+from qmctorch.utils import (plot_energy, plot_data)
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -16,65 +16,58 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69", calculator="adf", basis="dzp", unit="bohr"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='adf',
+               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
-)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='cas(2,2)',
+                   jastrow=jastrow,
+                   cuda=True)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=2000,
-    nstep=2000,
-    step_size=0.2,
-    ntherm=-1,
-    ndecor=100,
-    nelec=wf.nelec,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-    cuda=True,
-)
+sampler = Metropolis(nwalkers=2000,
+                     nstep=2000, step_size=0.2,
+                     ntherm=-1, ndecor=100,
+                     nelec=wf.nelec, init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'},
+                     cuda=True)
 
 
 # optimizer
-lr_dict = [
-    {"params": wf.jastrow.parameters(), "lr": 3e-3},
-    {"params": wf.ao.parameters(), "lr": 1e-6},
-    {"params": wf.mo.parameters(), "lr": 1e-3},
-    {"params": wf.fc.parameters(), "lr": 2e-3},
-]
-opt = optim.Adam(lr_dict, lr=1e-3)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
+           {'params': wf.ao.parameters(), 'lr': 1E-6},
+           {'params': wf.mo.parameters(), 'lr': 1E-3},
+           {'params': wf.fc.parameters(), 'lr': 2E-3}]
+opt = optim.Adam(lr_dict, lr=1E-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # 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()
 
 # optimize the wave function
 # configure the solver
-solver.configure(
-    track=["local_energy"],
-    freeze=["ao", "mo"],
-    loss="energy",
-    grad="auto",
-    ortho_mo=False,
-    clip_loss=False,
-    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-)
+solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                 loss='energy', grad='auto',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 50})
 
 # optimize the wave function
 obs = solver.run(250)
 
 plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-plot_data(solver.observable, obsname="jastrow.weight")
+plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/docs/example/graph/h2.py b/docs/example/graph/h2.py
index caed28ec..dd526405 100644
--- a/docs/example/graph/h2.py
+++ b/docs/example/graph/h2.py
@@ -7,13 +7,11 @@
 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"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='pyscf', basis='dzp', unit='bohr')
 
 # jastrow
 jastrow = JastrowFactor(mol, PadeJastrowKernel)
@@ -21,60 +19,38 @@
 
 # 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,
-    },
-)
+            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()
+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"),
-)
+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)
+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},
-)
+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
diff --git a/docs/example/graph/jast_graph.py b/docs/example/graph/jast_graph.py
index 0fee14d4..d294fd0a 100644
--- a/docs/example/graph/jast_graph.py
+++ b/docs/example/graph/jast_graph.py
@@ -1,8 +1,8 @@
+
 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
 
@@ -19,10 +19,10 @@
 )
 
 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},
-)
+            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)
diff --git a/docs/example/horovod/h2.py b/docs/example/horovod/h2.py
index 7ce8207b..4e4b76f3 100644
--- a/docs/example/horovod/h2.py
+++ b/docs/example/horovod/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import SolverMPI
 from qmctorch.sampler import Metropolis
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils import plot_energy, plot_data
+from qmctorch.utils import (plot_energy, plot_data)
 
 # bond distance : 0.74 A -> 1.38 a
 # optimal H positions +0.69 and -0.69
@@ -22,64 +22,51 @@
 set_torch_double_precision()
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69",
-    unit="bohr",
-    calculator="pyscf",
-    basis="sto-3g",
-    rank=hvd.local_rank(),
-    mpi_size=hvd.local_size(),
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69', unit='bohr',
+               calculator='pyscf', basis='sto-3g',
+               rank=hvd.local_rank(), mpi_size=hvd.local_size())
 
 
 # define the wave function
-wf = SlaterJastrow(mol, kinetic="jacobi", configs="cas(2,2)", cuda=use_cuda)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='cas(2,2)',
+                   cuda=use_cuda)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=200,
-    nstep=200,
-    step_size=0.2,
-    ntherm=-1,
-    ndecor=100,
-    nelec=wf.nelec,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-    cuda=use_cuda,
-)
+sampler = Metropolis(nwalkers=200,
+                     nstep=200, step_size=0.2,
+                     ntherm=-1, ndecor=100,
+                     nelec=wf.nelec, init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'},
+                     cuda=use_cuda)
 
 
 # optimizer
-lr_dict = [
-    {"params": wf.jastrow.parameters(), "lr": 3e-3},
-    {"params": wf.ao.parameters(), "lr": 1e-6},
-    {"params": wf.mo.parameters(), "lr": 1e-3},
-    {"params": wf.fc.parameters(), "lr": 2e-3},
-]
-opt = optim.Adam(lr_dict, lr=1e-3)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 3E-3},
+           {'params': wf.ao.parameters(), 'lr': 1E-6},
+           {'params': wf.mo.parameters(), 'lr': 1E-3},
+           {'params': wf.fc.parameters(), 'lr': 2E-3}]
+opt = optim.Adam(lr_dict, lr=1E-3)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.90)
 
 # QMC solver
-solver = SolverMPI(
-    wf=wf, sampler=sampler, optimizer=opt, scheduler=scheduler, rank=hvd.rank()
-)
+solver = SolverMPI(wf=wf, sampler=sampler,
+                                    optimizer=opt, scheduler=scheduler,
+                                    rank=hvd.rank())
 
 # configure the solver
-solver.configure(
-    track=["local_energy"],
-    freeze=["ao", "mo"],
-    loss="energy",
-    grad="auto",
-    ortho_mo=False,
-    clip_loss=False,
-    resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-)
+solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                 loss='energy', grad='auto',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 50})
 
 # optimize the wave function
 obs = solver.run(250)
 
 if hvd.rank() == 0:
     plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
-    plot_data(solver.observable, obsname="jastrow.weight")
+    plot_data(solver.observable, obsname='jastrow.weight')
diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 41354569..70f6fd28 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -7,7 +7,7 @@
 from qmctorch.solver import Solver
 from qmctorch.sampler import Metropolis, Hamiltonian
 from qmctorch.utils import set_torch_double_precision
-from qmctorch.utils.plot_data import plot_energy, plot_data
+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
 
@@ -21,15 +21,18 @@
 np.random.seed(0)
 
 # define the molecule
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69", calculator="pyscf", basis="sto-3g", unit="bohr"
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+               calculator='pyscf',
+               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=jastrow)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='single_double(2,2)',
+                   jastrow=jastrow)
 
 # sampler
 # sampler = Hamiltonian(nwalkers=100, nstep=100, nelec=wf.nelec,
@@ -37,24 +40,16 @@
 #                       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"),
-)
+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},
-    {"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)
+lr_dict = [{'params': wf.jastrow.parameters(), 'lr': 1E-2},
+           {'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)
 
 # scheduler
 scheduler = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.90)
@@ -66,20 +61,14 @@
 # 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,
-    resampling={
-        "mode": "update",
-        "resample_every": 1,
-        "nstep_update": 150,
-        "ntherm_update": 50,
-    },
-)
+solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
+                 loss='energy', grad='manual',
+                 ortho_mo=False, clip_loss=False,
+                 resampling={'mode': 'update',
+                             'resample_every': 1,
+                             'nstep_update': 150,
+                             'ntherm_update': 50}
+                 )
 
 # optimize the wave function
 obs = solver.run(5)  # , batchsize=10)
diff --git a/docs/example/scf/scf.py b/docs/example/scf/scf.py
index e7a263b8..bba8df9f 100644
--- a/docs/example/scf/scf.py
+++ b/docs/example/scf/scf.py
@@ -1,16 +1,24 @@
 from qmctorch.scf import Molecule
 
 # Select the SCF calculator
-calc = ["pyscf", "adf", "adf2019"][1]  # pyscf  # adf 2020+  # adf 2019
+calc = ['pyscf',            # pyscf  
+        'adf',              # adf 2020+ 
+        'adf2019'           # adf 2019
+    ][1]
 
 # select an appropriate basis
-basis = {"pyscf": "sto-6g", "adf": "VB1", "adf2019": "dz"}[calc]
+basis = {
+    'pyscf'  : 'sto-6g',
+    'adf'    : 'VB1',
+    'adf2019': 'dz'
+}[calc]
 
 # do the scf calculation
-mol = Molecule(
-    atom="H 0 0 -0.69; H 0 0 0.69",
-    calculator=calc,
-    basis=basis,
-    unit="bohr",
-    redo_scf=True,
-)
+mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
+            calculator=calc,
+            basis=basis,
+            unit='bohr',
+            redo_scf=True)
+
+
+
diff --git a/docs/example/single_point/h2.py b/docs/example/single_point/h2.py
index c443af8a..3a1c603c 100644
--- a/docs/example/single_point/h2.py
+++ b/docs/example/single_point/h2.py
@@ -4,33 +4,25 @@
 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"
-)
+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()
+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,
-)
+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)
diff --git a/docs/example/single_point/h2o_sampling.py b/docs/example/single_point/h2o_sampling.py
index d07b3086..507a78cb 100644
--- a/docs/example/single_point/h2o_sampling.py
+++ b/docs/example/single_point/h2o_sampling.py
@@ -7,31 +7,22 @@
 
 
 # define the molecule
-mol = Molecule(
-    atom="water.xyz",
-    unit="angs",
-    calculator="pyscf",
-    basis="sto-3g",
-    name="water",
-    redo_scf=True,
-)
+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", jastrow=jastrow)
+wf = SlaterJastrow(mol, kinetic='jacobi',
+                   configs='ground_state', jastrow=jastrow)
 
 # sampler
-sampler = Metropolis(
-    nwalkers=1000,
-    nstep=500,
-    step_size=0.25,
-    nelec=wf.nelec,
-    ndim=wf.ndim,
-    init=mol.domain("atomic"),
-    move={"type": "all-elec", "proba": "normal"},
-)
+sampler = Metropolis(nwalkers=1000, nstep=500, step_size=0.25,
+                     nelec=wf.nelec, ndim=wf.ndim,
+                     init=mol.domain('atomic'),
+                     move={'type': 'all-elec', 'proba': 'normal'})
 
 # solver
 solver = Solver(wf=wf, sampler=sampler)
@@ -46,4 +37,4 @@
 # compute the sampling traj
 pos = solver.sampler(solver.wf.pdf)
 obs = solver.sampling_traj(pos)
-plot_walkers_traj(obs.local_energy, walkers="mean")
+plot_walkers_traj(obs.local_energy, walkers='mean')
diff --git a/h5x/baseimport.py b/h5x/baseimport.py
index 9a1e941d..5c572f82 100644
--- a/h5x/baseimport.py
+++ b/h5x/baseimport.py
@@ -1,11 +1,7 @@
-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
+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" / __ \  /  |/  / ___/_  __/__  ________/ /  ")
diff --git a/qmctorch/__version__.py b/qmctorch/__version__.py
index f9aa3e11..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
index cf90b586..3ac3ba05 100644
--- a/qmctorch/ase/__init__.py
+++ b/qmctorch/ase/__init__.py
@@ -1 +1 @@
-from .ase import QMCTorch
+from .ase import QMCTorch 
\ No newline at end of file
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 5ff3f0bd..cf7f72eb 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -9,26 +9,21 @@
 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 ..wavefunction.orbitals.backflow import BackFlowTransformation, BackFlowKernelInverse
 from ..solver import Solver
 from ..sampler import Metropolis
 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:
+    def __init__(self,
+                 restart: str = None,
+                 *,
+                 labels: list = None,
+                 atoms: Atoms = None,
+                 **kwargs: dict) -> None:
         """
         Initialize a QMCTorchCalculator object.
 
@@ -57,69 +52,58 @@ def __init__(
 
         # default options for the SCF
         self.molecule = None
-        self.scf_options = SimpleNamespace(calculator="pyscf", basis="dzp", scf="hf")
+        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,
-            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.wf_options = SimpleNamespace(kinetic='jacobi',
+                                          configs='single_double(2,2)',
+                                          orthogonalize_mo=True,
+                                          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.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
-        )
+        self.sampler_options = SimpleNamespace(nwalkers=4000, nstep=2000, 
+                                               ntherm=-1, ndecor=1, step_size=0.05)
         self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
-
-        # optimizer ....
+        
+        # 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.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()
-        )
-
+        self.recognized_resampling_options = list(self.solver_options.resampling.__dict__.keys())
+        
     @staticmethod
-    def validate_options(
-        options: SimpleNamespace, recognized_options: list, name: str = ""
-    ) -> None:
+    def validate_options(options: SimpleNamespace, recognized_options: list, name: str = "") -> None:
         """
         Validate that the options provided are valid.
 
@@ -144,8 +128,7 @@ def validate_options(
         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)
+                    "Invalid %s options: %s. Recognized options are %s" % (name, opt, recognized_options)
                 )
 
     def run_scf(self) -> None:
@@ -165,20 +148,17 @@ def run_scf(self) -> None:
         -------
         None
         """
-        self.validate_options(self.scf_options, self.recognized_scf_options, "SCF")
+        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,
-        )
+        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:
         """
@@ -195,51 +175,37 @@ def set_wf(self) -> None:
         # 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,
-            )
+            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,
-            )
+            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,
-            orthogonalize_mo=self.wf_options.orthogonalize_mo,
-            include_all_mo=self.wf_options.include_all_mo,
-            cuda=self.use_cuda,
-        )
-
+        #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,
+                                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":
+            if self.scf_options.calculator != 'pyscf':
                 raise ValueError("gto2sto is only supported for pyscf")
             self.wf = self.wf.gto2sto()
 
@@ -260,60 +226,44 @@ def set_sampler(self) -> None:
         """
         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"),
-            cuda=self.use_cuda,
-        )
-
+        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'), 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)
+        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
+        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
+        - 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`
+        - 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"
-        ):
+        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
-            )
+            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"
-        ):
+        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
 
@@ -342,36 +292,24 @@ def initialize(self) -> None:
 
         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.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__,
-        )
+        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:
         """
@@ -384,6 +322,7 @@ def set_atoms(self, atoms: Atoms) -> None:
         """
         self.atoms = atoms
 
+
     def reset(self) -> None:
         """
         Reset the internal state of the QMCTorchCalculator.
@@ -407,8 +346,8 @@ 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
+        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 = {}
@@ -438,10 +377,7 @@ def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
         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),
-            ):
+            if not np.allclose(self.atoms.get_positions() * ANGS2BOHR, np.array(self.molecule.atom_coords)):
                 self.reset()
                 self.set_atoms(atoms)
                 self.initialize()
@@ -449,27 +385,23 @@ def reset_solver(self, atoms: Atoms = None, force: bool = True) -> None:
             if self.solver is None:
                 self.initialize()
 
-    def calculate(
-        self,
-        atoms: Atoms = None,
-        properties: list = ["energy"],
-        system_changes: any = None,
-    ) -> float:
+    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
+        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
+            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'
+            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.
@@ -486,7 +418,7 @@ def calculate(
 
         Notes
         -----
-        The method first resets the solver if needed, checks the validity of the
+        The method first resets the solver if needed, checks the validity of the 
         requested properties, and then computes each property one-by-one.
         """
 
@@ -495,25 +427,25 @@ def calculate(
 
         # check properties that are needed
         if any([p not in self.implemented_properties for p in properties]):
-            raise ValueError("property not recognized")
-
+            raise ValueError('property not recognized')
+        
         # compute
         for p in properties:
-            if p == "forces":
+            if p == 'forces':
                 return self._calculate_forces(atoms=atoms)
 
-            elif p == "energy":
+            elif p == 'energy':
                 return self._calculate_energy(atoms=atoms)
 
-    def _calculate_energy(self, atoms: Atoms = None) -> float:
-        # check if reset is necessary
+    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
+            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
@@ -534,14 +466,15 @@ def _calculate_energy(self, atoms: Atoms = None) -> float:
             self.solver.set_params_requires_grad(wf_params=True, geo_params=False)
             self.solver.run(self.solver_options.niter, tqdm=self.solver_options.tqdm)
 
-        # compute the energy
+        # compute the energy 
         observable = self.solver.single_point()
 
         # store and output
-        self.results["energy"] = observable.energy
-        return self.results["energy"]
+        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.
@@ -549,7 +482,7 @@ def _calculate_forces(self, atoms: Atoms = None) -> float:
         Parameters
         ----------
         atoms : ASE Atoms object, optional
-            The atoms object to be used for the computation. If not provided, the calculator
+            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
@@ -570,19 +503,19 @@ def _calculate_forces(self, atoms: Atoms = None) -> float:
         # resample
         observable = self.solver.single_point()
 
-        # compute the forces
+        # compute the forces 
         # we use evaluate_grad_auto as evaluate_grad_manual is not
-        # valid for forces
+        # valid for forces  
         self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
         _, _ = self.solver.evaluate_grad_auto(observable.pos)
 
         # store and output
-        self.results["energy"] = observable.energy.cpu().numpy()
-        self.results["forces"] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.results['energy'] = observable.energy.cpu().numpy()
+        self.results['forces'] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
         self.solver.wf.zero_grad()
 
         self.has_forces = True
-        return self.results["forces"]
+        return self.results['forces']
 
     def check_forces(self) -> bool:
         """
@@ -593,11 +526,11 @@ def check_forces(self) -> bool:
         bool
             True if the forces have been computed, False otherwise.
         """
-        if (self.has_forces) and ("forces" in self.results):
+        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.
@@ -612,14 +545,14 @@ def get_forces(self, atoms: Atoms = None) -> np.ndarray:
         forces : array
             The total forces on the atoms.
         """
-
+        
         self.reset_solver(atoms=atoms)
         if self.check_forces():
-            return self.results["forces"]
+            return self.results['forces']
         else:
             return self._calculate_forces(atoms=atoms)
-
-    def get_total_energy(self, atoms: Atoms = None) -> float:
+    
+    def get_total_energy(self, atoms: Atoms=None) -> float:
         """
         Return the total energy.
 
@@ -634,7 +567,7 @@ def get_total_energy(self, atoms: Atoms = None) -> float:
             The total energy of the system.
         """
         self.reset_solver(atoms=atoms)
-        if "energy" in self.results:
-            return self.results["energy"]
+        if 'energy' in self.results:
+            return self.results['energy']
         else:
-            return self._calculate_energy(atoms=atoms)
+            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
index f05c1bc9..fc36af9c 100644
--- a/qmctorch/ase/optimizer/__init__.py
+++ b/qmctorch/ase/optimizer/__init__.py
@@ -1 +1 @@
-from .torch_optim import TorchOptimizer
+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
index 5f3c9fd0..55456cca 100644
--- a/qmctorch/ase/optimizer/torch_optim.py
+++ b/qmctorch/ase/optimizer/torch_optim.py
@@ -9,25 +9,25 @@
 from ase import Atoms
 from ase.optimize.optimize import Optimizer
 from ase.utils import deprecated
-from ...utils.constants import BOHR2ANGS
-
-
+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)
 
+    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
@@ -56,7 +56,7 @@ def log(self, e: float, forces: np.ndarray) -> float:
         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())
+        fmax = sqrt((forces ** 2).sum(axis=1).max())
         T = time.localtime()
         if self.logfile is not None:
             name = self.__class__.__name__
@@ -70,10 +70,8 @@ def log(self, e: float, forces: np.ndarray) -> float:
             self.logfile.write(msg)
             self.logfile.flush()
         return fmax
-
-    def run(
-        self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt"
-    ) -> SimpleNamespace:
+    
+    def run(self, fmax: float, steps: int = 10, hdf5_group: str = "geo_opt") -> SimpleNamespace:
         """
         Run a geometry optimization.
 
@@ -102,7 +100,7 @@ def run(
         solver = self.atoms.calc.solver
 
         if self.opt_geo is None:
-            self.opt_geo = SGD(solver.wf.parameters(), lr=1e-2)
+            self.opt_geo = SGD(solver.wf.parameters(), lr=1E-2)
             self.opt_geo.lpos_needed = False
 
         # save the optimizer used for the wf params
@@ -125,30 +123,26 @@ def run(
         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.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))
+            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
-            )
+            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)
-            )
+            self.optimizable.set_positions(solver.wf.geometry(None,convert_to_angs=True))
             current_fmax = self.log(cumulative_loss, forces)
             self.call_observers()
 
diff --git a/qmctorch/sampler/generalized_metropolis.py b/qmctorch/sampler/generalized_metropolis.py
index 7fb42af4..50d088c7 100644
--- a/qmctorch/sampler/generalized_metropolis.py
+++ b/qmctorch/sampler/generalized_metropolis.py
@@ -43,12 +43,9 @@ def __init__(  # pylint: disable=dangerous-default-value
             self, nwalkers, nstep, step_size, ntherm, ndecor, nelec, ndim, init, cuda
         )
 
-    def __call__(
-        self,
-        pdf: Callable[[torch.Tensor], torch.Tensor],
-        pos: Optional[torch.Tensor] = None,
-        with_tqdm: bool = True,
-    ) -> torch.Tensor:
+    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:
@@ -144,7 +141,9 @@ def move(self, drift: torch.Tensor) -> torch.Tensor:
         # Return reshaped positions
         return new_pos.view(self.walkers.nwalkers, self.nelec * self.ndim)
 
-    def _move(self, drift: torch.Tensor, index: int) -> torch.Tensor:
+    def _move(
+        self, drift: torch.Tensor, index: int
+    ) -> torch.Tensor:
         """Move a walker.
 
         Args:
@@ -169,9 +168,7 @@ def _move(self, drift: torch.Tensor, index: int) -> torch.Tensor:
             + mv.sample((self.walkers.nwalkers, 1)).squeeze()
         )
 
-    def trans(
-        self, xf: torch.Tensor, xi: torch.Tensor, drifti: torch.Tensor
-    ) -> torch.Tensor:
+    def trans(self, xf: torch.Tensor, xi: torch.Tensor, drifti: torch.Tensor) -> torch.Tensor:
         """Transform the positions
 
         Args:
diff --git a/qmctorch/sampler/hamiltonian.py b/qmctorch/sampler/hamiltonian.py
index 4ddea9f8..96b9a146 100644
--- a/qmctorch/sampler/hamiltonian.py
+++ b/qmctorch/sampler/hamiltonian.py
@@ -42,9 +42,8 @@ def __init__(
         self.traj_length = L
 
     @staticmethod
-    def get_grad(
-        func: Callable[[torch.Tensor], torch.Tensor], inp: torch.Tensor
-    ) -> torch.Tensor:
+    def get_grad(func: Callable[[torch.Tensor], torch.Tensor],
+                 inp: torch.Tensor) -> torch.Tensor:
         """get the gradient of the pdf using autograd
 
         Args:
@@ -77,12 +76,9 @@ def log_func(func: Callable[[torch.Tensor], torch.Tensor]):
         """
         return lambda x: -torch.log(func(x))
 
-    def __call__(
-        self,
-        pdf: Callable[[torch.Tensor], torch.Tensor],
-        pos: Optional[torch.Tensor] = None,
-        with_tqdm: bool = True,
-    ) -> torch.Tensor:
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor],
+                 pos: Optional[torch.Tensor] = None,
+                 with_tqdm: bool = True) -> torch.Tensor:
         """Generate walkers following HMC
 
         Generates a series of walkers following the HMC algorithm
@@ -140,15 +136,11 @@ def __call__(
         return torch.cat(pos).requires_grad_()
 
     @staticmethod
-    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]:
+    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:
diff --git a/qmctorch/sampler/metropolis_all_elec.py b/qmctorch/sampler/metropolis_all_elec.py
index b7a66c29..bcb00645 100644
--- a/qmctorch/sampler/metropolis_all_elec.py
+++ b/qmctorch/sampler/metropolis_all_elec.py
@@ -75,9 +75,8 @@ def log_data(self) -> None:
         log.info("  Move proba          : {0}", self.movedict["proba"])
 
     @staticmethod
-    def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
-    ) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the log of a function
 
         Args:
diff --git a/qmctorch/sampler/metropolis_hasting_all_elec.py b/qmctorch/sampler/metropolis_hasting_all_elec.py
index 584c3753..cc251d55 100644
--- a/qmctorch/sampler/metropolis_hasting_all_elec.py
+++ b/qmctorch/sampler/metropolis_hasting_all_elec.py
@@ -65,9 +65,8 @@ def log_data(self) -> None:
         # log.info('  Move type           : {0}', 'all-elec')
 
     @staticmethod
-    def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
-    ) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]
+                 ) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of  a function
 
         Args:
diff --git a/qmctorch/sampler/pints_sampler.py b/qmctorch/sampler/pints_sampler.py
index befbe65b..bd8cfa0f 100644
--- a/qmctorch/sampler/pints_sampler.py
+++ b/qmctorch/sampler/pints_sampler.py
@@ -13,7 +13,7 @@ def __init__(self, pdf: Callable[[torch.Tensor], torch.Tensor], ndim: int) -> No
             pdf: wf.pdf function
             ndim: number of dimensions
         """
-        self.pdf = pdf
+        self.pdf = pdf 
         self.ndim = ndim
 
     def __call__(self, x: numpy.ndarray) -> numpy.ndarray:
@@ -114,9 +114,7 @@ def log_data(self):
         #     '  Sampler             : {0}', self.method.name(None))
 
     @staticmethod
-    def log_func(
-        func: Callable[[torch.Tensor], torch.Tensor]
-    ) -> Callable[[torch.Tensor], torch.Tensor]:
+    def log_func(func: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
         """Compute the negative log of a function
 
         Args:
diff --git a/qmctorch/sampler/proposal_kernels.py b/qmctorch/sampler/proposal_kernels.py
index 0c4d6f7e..508a9290 100644
--- a/qmctorch/sampler/proposal_kernels.py
+++ b/qmctorch/sampler/proposal_kernels.py
@@ -3,8 +3,7 @@
 
 class BaseProposalKernel(object):
     def __call__(self, x):
-        raise NotImplementedError
-
+        raise NotImplementedError   
 
 class DensityVarianceKernel(BaseProposalKernel):
     def __init__(self, atomic_pos, sigma=1.0, scale_factor=1.0):
diff --git a/qmctorch/sampler/sampler_base.py b/qmctorch/sampler/sampler_base.py
index 46729b03..9f037ed2 100644
--- a/qmctorch/sampler/sampler_base.py
+++ b/qmctorch/sampler/sampler_base.py
@@ -61,9 +61,7 @@ def __init__(
         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:
+    def __call__(self, pdf: Callable[[torch.Tensor], torch.Tensor], *args, **kwargs) -> torch.Tensor:
         """
         Evaluate the sampling algorithm.
 
diff --git a/qmctorch/sampler/state_dependent_normal_proposal.py b/qmctorch/sampler/state_dependent_normal_proposal.py
index 2176dfae..89196d1e 100644
--- a/qmctorch/sampler/state_dependent_normal_proposal.py
+++ b/qmctorch/sampler/state_dependent_normal_proposal.py
@@ -41,13 +41,13 @@ def __call__(self, x: torch.Tensor) -> torch.Tensor:
         """
         nwalkers = x.shape[0]
         scale = self.kernel(x)  # shape (nwalkers, nelec*ndim)
-        displacement = self.multiVariate.sample(
-            (nwalkers, self.nelec)
-        )  # 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:
+    def get_transition_ratio(
+        self, x: torch.Tensor, y: torch.Tensor
+    ) -> torch.Tensor:
         """
         Compute the transition ratio for the Metropolis-Hastings acceptance probability.
 
diff --git a/qmctorch/scf/calculator/adf.py b/qmctorch/scf/calculator/adf.py
index c72d2d0e..5f94a4f3 100644
--- a/qmctorch/scf/calculator/adf.py
+++ b/qmctorch/scf/calculator/adf.py
@@ -63,14 +63,10 @@ def __init__(  # pylint: disable=too-many-arguments
         )
 
         if charge != 0:
-            raise ValueError(
-                "ADF calculator does not support charge yet, open an issue in the repo :)"
-            )
-
+            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 :)"
-            )
+            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"]
@@ -132,7 +128,7 @@ def finish_plams(self) -> None:
     def get_plams_molecule(self) -> plams.Molecule:
         """Returns a plams molecule object."""
         mol = plams.Molecule()
-        bohr2angs = BOHR2ANGS  # the coordinate are always in bohr
+        bohr2angs = BOHR2ANGS # the coordinate are always in bohr
         for at, xyz in zip(self.atoms, self.atom_coords):
             xyz = list(bohr2angs * np.array(xyz))
             mol.add_atom(plams.Atom(symbol=at, coords=tuple(xyz)))
@@ -295,7 +291,7 @@ def get_basis_data(self, kffile: str) -> SimpleNamespace:
         return basis
 
     @staticmethod
-    def read_array(kf: BinaryIO, section: str, name: str) -> np.ndarray:
+    def read_array(kf: BinaryIO , section: str, name: str) -> np.ndarray:
         """read a data from the kf file
 
         Args:
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 6e22e966..c2429a0b 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -60,7 +60,7 @@ def __init__(  # pylint: disable=too-many-arguments
 
         Returns:
             None
-
+        
         Examples:
             >>> from qmctorch.scf import Molecule
             >>> mol = Molecule(atom='H 0 0 0; H 0 0 1', unit='angs',
diff --git a/qmctorch/solver/loss.py b/qmctorch/solver/loss.py
index 8f2276cf..856a50e8 100644
--- a/qmctorch/solver/loss.py
+++ b/qmctorch/solver/loss.py
@@ -3,9 +3,11 @@
 from torch import nn
 from ..wavefunction import WaveFunction
 
-
 class Loss(nn.Module):
-    def __init__(self, wf: WaveFunction, method: str = "energy", clip: bool = False):
+    def __init__(self, 
+                 wf: WaveFunction, 
+                 method: str = "energy", 
+                 clip: bool = False):
         """Defines the loss to use during the optimization
 
         Arguments:
@@ -41,15 +43,18 @@ def __init__(self, wf: WaveFunction, method: str = "energy", clip: bool = False)
         self.weight = {"psi": None, "psi0": None}
 
     def forward(
-        self, pos: torch.Tensor, no_grad: bool = False, deactivate_weight: bool = False
+        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
+            no_grad (bool, optional): Computes the gradient of the loss 
                                       (default: {False})
-            deactivate_weight (bool, optional): Deactivates the weight computation
+            deactivate_weight (bool, optional): Deactivates the weight computation 
                                                (default: {False})
 
         Returns:
@@ -137,4 +142,4 @@ def get_sampling_weights(
             return w
 
         else:
-            return torch.tensor(1.0)
+            return torch.tensor(1.0)
\ No newline at end of file
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 2b3b9fba..6c682c08 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -6,12 +6,11 @@
 import torch
 from ..wavefunction import WaveFunction
 from ..sampler import SamplerBase
-from ..utils import OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
+from ..utils import  OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
 from .. import log
 from .solver_base import SolverBase
 from .loss import Loss
 
-
 class Solver(SolverBase):
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -102,14 +101,12 @@ def configure(
         # orthogonalization penalty for the MO coeffs
         self.ortho_mo = ortho_mo
         if self.ortho_mo is True:
-            log.warning(
-                "Orthogonalization of the MO coeffs is better done in the wave function"
-            )
+            log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
             self.ortho_loss = OrthoReg()
 
-    def set_params_requires_grad(
-        self, wf_params: Optional[bool] = True, geo_params: Optional[bool] = 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
@@ -180,13 +177,14 @@ def restore_sampling_parameters(self) -> None:
         self.sampler.ntherm = self.sampler._ntherm_save
         # self.sampler.walkers.nwalkers = self.sampler._nwalker_save
 
+
     def run(
-        self,
-        nepoch: int,
-        batchsize: Optional[int] = None,
-        hdf5_group: Optional[str] = "wf_opt",
-        chkpt_every: Optional[int] = None,
-        tqdm: Optional[bool] = False,
+        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
 
@@ -215,9 +213,7 @@ def run(
 
         return self.observable
 
-    def prepare_optimization(
-        self, batchsize: int, chkpt_every: int, tqdm: Optional[bool] = False
-    ):
+    def prepare_optimization(self, batchsize: int, chkpt_every: int , tqdm: Optional[bool] = False):
         """Prepare the optimization process
 
         Args:
@@ -260,12 +256,9 @@ def save_data(self, hdf5_group: str):
 
         add_group_attr(self.hdf5file, hdf5_group, {"type": "opt"})
 
-    def run_epochs(
-        self,
-        nepoch: int,
-        with_tqdm: Optional[bool] = False,
-        verbose: Optional[bool] = True,
-    ) -> float:
+    def run_epochs(self, nepoch: int, 
+                   with_tqdm: Optional[bool] = False, 
+                   verbose: Optional[bool] = True) -> float :
         """Run a certain number of epochs
 
         Args:
@@ -278,8 +271,8 @@ def run_epochs(
         # init the loss in case we have nepoch=0
         cumulative_loss = 0
         min_loss = 0  # this is set at n=0
-
-        # the range
+        
+        # the range 
         rng = tqdm(
             range(nepoch),
             desc="INFO:QMCTorch|  Optimization",
@@ -288,12 +281,12 @@ def run_epochs(
 
         # loop over the epoch
         for n in rng:
+
             if verbose:
                 tstart = time()
                 log.info("")
                 log.info(
-                    "  epoch %d | %d sampling points"
-                    % (n, len(self.dataloader.dataset))
+                    "  epoch %d | %d sampling points" % (n, len(self.dataloader.dataset))
                 )
 
             # reset the gradients and loss
@@ -346,9 +339,7 @@ def run_epochs(
 
         return cumulative_loss
 
-    def evaluate_grad_auto(
-        self, lpos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    def evaluate_grad_auto(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Evaluate the gradient using automatic differentiation
 
         Args:
@@ -370,14 +361,12 @@ def evaluate_grad_auto(
 
         return loss, eloc
 
-    def evaluate_grad_manual(
-        self, lpos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
-
+        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:
@@ -421,13 +410,11 @@ def evaluate_grad_manual(
 
         else:
             raise ValueError("Manual gradient only for energy minimization")
-
-    def evaluate_grad_manual_2(
-        self, lpos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        
+    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
+        as it does not include derivative of the hamiltonian 
         wrt atomic positions
 
         https://www.cond-mat.de/events/correl19/manuscripts/luechow.pdf eq. 17
@@ -460,10 +447,10 @@ def evaluate_grad_manual_2(
             psi = self.wf(lpos)
             norm = 2.0 / len(psi)
 
-            weight1 = norm * eloc / psi.detach().clone()
-            weight2 = -norm * eloc_mean / psi.detach().clone()
+            weight1 = norm * eloc/psi.detach().clone()
+            weight2 = -norm * eloc_mean/psi.detach().clone()
 
-            psi.backward(weight1, retain_graph=True)
+            psi.backward(weight1,retain_graph=True) 
             psi.backward(weight2)
 
             return torch.mean(eloc), eloc
diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 9cc441d3..d919560d 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -11,7 +11,6 @@
 from ..utils import add_group_attr, dump_to_hdf5
 from ..utils import get_git_tag
 
-
 class SolverBase:
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -66,6 +65,7 @@ def __init__(  # pylint: disable=too-many-arguments
             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)
@@ -75,8 +75,8 @@ def __init__(  # pylint: disable=too-many-arguments
 
     def configure_resampling(  # pylint: disable=too-many-arguments
         self,
-        mode: str = "update",
-        resample_every: int = 1,
+        mode: str ="update",
+        resample_every: int =1,
         nstep_update: int = 25,
         ntherm_update: int = -1,
         increment: Dict = {"every": None, "factor": None},
@@ -145,7 +145,7 @@ def track_observable(self, obs_name: Union[str, List[str]]):
         # 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"]
@@ -172,13 +172,10 @@ def track_observable(self, obs_name: Union[str, List[str]]):
 
         self.observable.models = SimpleNamespace()
 
-    def store_observable(
-        self,
-        pos: torch.tensor,
-        local_energy: Optional[torch.tensor] = None,
-        ibatch: Optional[int] = 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:
@@ -270,7 +267,7 @@ def print_observable(self, cumulative_loss: float, verbose: bool = False):
                 )
                 log.options(style="percent").info("loss %f" % (cumulative_loss))
 
-    def resample(self, n: int, pos: torch.tensor) -> torch.tensor:
+    def resample(self, n : int, pos: torch.tensor) -> torch.tensor:
         """Resample the wave function
 
         Args:
@@ -313,12 +310,9 @@ def resample(self, n: int, pos: torch.tensor) -> torch.tensor:
 
         return pos
 
-    def single_point(
-        self,
-        with_tqdm: Optional[bool] = True,
-        batchsize: Optional[int] = None,
-        hdf5_group: str = "single_point",
-    ):
+    def single_point(self, with_tqdm: Optional[bool] = True, 
+                     batchsize: Optional[int] = None, 
+                     hdf5_group: str = "single_point"):
         """Performs a single point calculation
 
         Args:
@@ -386,7 +380,7 @@ def single_point(
 
         return obs
 
-    def save_checkpoint(self, epoch: int, loss: float):
+    def save_checkpoint(self, epoch: int , loss: float):
         """save the model and optimizer state
 
         Args:
@@ -420,7 +414,7 @@ def load_checkpoint(self, filename: str) -> Tuple[int, float]:
         loss = data["loss"]
         return epoch, loss
 
-    def _append_observable(self, key: str, data: Any):
+    def _append_observable(self, key : str, data: Any):
         """Append a new data point to observable key.
 
         Arguments:
@@ -432,12 +426,10 @@ def _append_observable(self, key: str, data: Any):
             self.obs_dict[key] = []
         self.obs_dict[key].append(data)
 
-    def sampling_traj(
-        self,
-        pos: Optional[torch.tensor] = None,
-        with_tqdm: Optional[bool] = True,
-        hdf5_group: Optional[str] = "sampling_trajectory",
-    ) -> torch.tensor:
+    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:
@@ -467,7 +459,7 @@ def sampling_traj(
         add_group_attr(self.hdf5file, hdf5_group, {"type": "sampling_traj"})
         return obs
 
-    def print_parameters(self, grad: Optional[bool] = False) -> None:
+    def print_parameters(self, grad: Optional[bool]=False) -> None:
         """print parameter values
 
         Args:
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index d2836582..88d0780d 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -22,15 +22,15 @@ def logd(rank: int, *args):
 
 
 class SolverMPI(Solver):
-    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:
+    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:
@@ -208,10 +208,10 @@ def run(  # pylint: disable=too-many-arguments
         return self.observable
 
     def single_point(
-        self,
-        with_tqdm: bool = True,
-        batchsize: Optional[int] = None,
-        hdf5_group: str = "single_point",
+        self, 
+        with_tqdm: bool = True, 
+        batchsize: Optional[int] = None, 
+        hdf5_group: str = "single_point"
     ) -> SimpleNamespace:
         """Performs a single point calculation
 
diff --git a/qmctorch/utils/algebra_utils.py b/qmctorch/utils/algebra_utils.py
index 6d3df4a1..f8d2a5de 100644
--- a/qmctorch/utils/algebra_utils.py
+++ b/qmctorch/utils/algebra_utils.py
@@ -3,7 +3,6 @@
 from typing import List
 from scipy.special import factorial2 as f2
 
-
 def btrace(M: torch.Tensor) -> torch.Tensor:
     """Computes the trace of batched matrices
 
@@ -52,7 +51,7 @@ def double_factorial(input: List) -> np.ndarray:
         List: values of the double factorial
     """
     output = f2(input)
-    return np.array([1 if o == 0 else o for o in output])
+    return np.array([1 if o==0 else o for o in output])
 
 
 class BatchDeterminant(torch.autograd.Function):
diff --git a/qmctorch/utils/constants.py b/qmctorch/utils/constants.py
index a7ff07d8..ff8745e0 100644
--- a/qmctorch/utils/constants.py
+++ b/qmctorch/utils/constants.py
@@ -1,2 +1,2 @@
 ANGS2BOHR = 1.8897259886
-BOHR2ANGS = 0.529177
+BOHR2ANGS = 0.529177
\ No newline at end of file
diff --git a/qmctorch/utils/hdf5_utils.py b/qmctorch/utils/hdf5_utils.py
index eb38cea3..cb7a46a7 100644
--- a/qmctorch/utils/hdf5_utils.py
+++ b/qmctorch/utils/hdf5_utils.py
@@ -6,7 +6,6 @@
 
 from .. import log
 
-
 def print_insert_error(obj, obj_name):
     print(obj_name, obj)
     log.critical(
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index ad40becb..a675e80b 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -60,9 +60,7 @@ def get_mo_max_index(self, orb: str) -> int:
         else:
             raise ValueError("orb must occupied or all")
 
-    def interpolate_mo_irreg_grid(
-        self, pos: torch.Tensor, n: int, orb: str
-    ) -> torch.Tensor:
+    def interpolate_mo_irreg_grid(self, pos: torch.Tensor, n: int, orb: str) -> torch.Tensor:
         """Interpolate the molecular orbitals occupied in the configs.
 
         Args:
@@ -82,15 +80,13 @@ 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()
+                return mo[:, :self.mo_max_index].detach()
 
             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[:, :, :self.mo_max_index] = interpolate_irreg_grid(self.interp_mo_func, pos)
         return mos
 
     def interpolate_mo_reg_grid(
@@ -134,9 +130,7 @@ def __init__(self, wf):
         """Interpolation of the AO using a log grid centered on each atom."""
         self.wf = wf
 
-    def __call__(
-        self, pos: torch.Tensor, n: int = 6, length: float = 2
-    ) -> torch.Tensor:
+    def __call__(self, pos: torch.Tensor, n: int = 6, length: float = 2) -> torch.Tensor:
         """Interpolate the AO.
 
         Args:
@@ -175,7 +169,9 @@ def __call__(
 
         return torch.as_tensor(data.transpose(1, 2, 0))
 
-    def get_interpolator(self, n: int = 6, length: float = 2) -> None:
+    def get_interpolator(
+        self, n: int = 6, length: float = 2
+    ) -> None:
         """evaluate the interpolation function.
 
         Args:
@@ -262,9 +258,9 @@ def get_boundaries(
 
 
 def get_reg_grid(
-    atomic_positions: Union[torch.Tensor, np.ndarray, list],
-    resolution: float = 0.1,
-    border_length: float = 2.0,
+    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
 
@@ -315,7 +311,8 @@ def interpolator_reg_grid(
 
 
 def interpolate_reg_grid(
-    interpfunc: Callable[[np.ndarray], np.ndarray], pos: torch.Tensor
+    interpfunc: Callable[[np.ndarray], np.ndarray],
+    pos: torch.Tensor
 ) -> torch.Tensor:
     """Interpolate the function
 
@@ -398,9 +395,7 @@ def get_log_grid(
     return grid_pts
 
 
-def interpolator_irreg_grid(
-    func: Callable[[np.ndarray], torch.Tensor], grid_pts: np.ndarray
-) -> Callable:
+def interpolator_irreg_grid(func: Callable[[np.ndarray], torch.Tensor], grid_pts: np.ndarray) -> Callable:
     """Compute a linear ND interpolator
 
     Args:
@@ -414,7 +409,8 @@ def interpolator_irreg_grid(
 
 
 def interpolate_irreg_grid(
-    interpfunc: Callable[[np.ndarray], np.ndarray], pos: torch.Tensor
+    interpfunc: Callable[[np.ndarray], np.ndarray],
+    pos: torch.Tensor
 ) -> torch.Tensor:
     """Interpolate the function
 
@@ -427,6 +423,4 @@ def interpolate_irreg_grid(
     """
 
     nbatch, nelec, ndim = pos.shape[0], pos.shape[1] // 3, 3
-    return torch.as_tensor(
-        interpfunc(pos.reshape(nbatch, nelec, ndim).detach().numpy())
-    )
+    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 6376e36e..15222765 100644
--- a/qmctorch/utils/plot_data.py
+++ b/qmctorch/utils/plot_data.py
@@ -12,10 +12,10 @@
 
 
 def plot_energy(
-    local_energy: np.ndarray,
-    e0: Optional[float] = None,
-    show_variance: bool = False,
-    clip: bool = False,
+    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.
@@ -27,7 +27,6 @@ def plot_energy(
         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()
@@ -52,7 +51,9 @@ def clip_values(values: np.ndarray, std_factor: int = 5) -> np.ndarray:
     q25 = np.array([np.quantile(clip_values(e), 0.5 - q) for e in local_energy])
 
     # plot
-    ax.fill_between(epoch, q25, q75, alpha=0.5, color="#4298f4")
+    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="--")
@@ -71,7 +72,10 @@ def clip_values(values: np.ndarray, std_factor: int = 5) -> np.ndarray:
     plt.show()
 
 
-def plot_data(observable: SimpleNamespace, obsname: str) -> None:
+def plot_data(
+    observable: SimpleNamespace, 
+    obsname: str
+) -> None:
     """Plot the evolution of a given data
 
     Args:
@@ -89,9 +93,7 @@ def plot_data(observable: SimpleNamespace, obsname: str) -> None:
     plt.show()
 
 
-def plot_walkers_traj(
-    eloc: np.ndarray, walkers: Union[int, str, None] = "mean"
-) -> None:
+def plot_walkers_traj(eloc: np.ndarray, walkers: Union[int, str, None] = "mean") -> None:
     """Plot the trajectory of all the individual walkers
 
     Args:
@@ -171,7 +173,10 @@ def plot_correlation_coefficient(
 
 
 def plot_integrated_autocorrelation_time(
-    eloc: np.ndarray, rho: np.ndarray = None, size_max: int = 100, C: int = 5
+    eloc: np.ndarray,
+    rho: np.ndarray = None,
+    size_max: int = 100,
+    C: int = 5
 ) -> int:
     """Compute and plot the integrated autocorrelation time.
 
@@ -218,9 +223,7 @@ def plot_integrated_autocorrelation_time(
     return ii
 
 
-def plot_blocking_energy(
-    eloc: np.ndarray, block_size: int, walkers: str = "mean"
-) -> np.ndarray:
+def plot_blocking_energy(eloc: np.ndarray, block_size: int, walkers: str = "mean") -> np.ndarray:
     """Plot the blocked energy values
 
     Args:
diff --git a/qmctorch/utils/provenance.py b/qmctorch/utils/provenance.py
index b6a4bf1c..9bc8d7ac 100644
--- a/qmctorch/utils/provenance.py
+++ b/qmctorch/utils/provenance.py
@@ -9,17 +9,13 @@ def get_git_tag() -> str:
 
     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")
-        )
+        gittag = subprocess.check_output(["git", "describe", "--always"], cwd=cwd).decode("utf-8").strip("\n")
         return __version__ + " - " + gittag
     except:
-        return __version__ + " - hash commit not found"
+        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 7afbd1fc..e734159d 100644
--- a/qmctorch/utils/stat_utils.py
+++ b/qmctorch/utils/stat_utils.py
@@ -3,8 +3,11 @@
 from scipy.signal import fftconvolve
 from typing import Tuple
 
-
-def blocking(x: np.ndarray, block_size: int, expand: bool = False) -> np.ndarray:
+def blocking(
+    x: np.ndarray,
+    block_size: int,
+    expand: bool = False
+) -> np.ndarray:
     """block the data
 
     Args:
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index c9cc8d25..04a41977 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -10,7 +10,7 @@ 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.backends.cudnn.allow_tf32  = False
     # torch.set_default_tensor_type(torch.DoubleTensor)
 
 
@@ -18,15 +18,15 @@ 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.backends.cudnn.allow_tf32  = False
     # torch.set_default_tensor_type(torch.FloatTensor)
 
 
 def fast_power(
-    x: torch.Tensor,
-    k: torch.Tensor,
-    mask0: Optional[torch.Tensor] = None,
-    mask2: Optional[torch.Tensor] = None,
+    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.
@@ -78,8 +78,10 @@ def gradients(
 
 
 def diagonal_hessian(
-    out: torch.Tensor, inp: torch.Tensor, return_grads: bool = False
-) -> torch.Tensor:
+        out: torch.Tensor, 
+        inp: torch.Tensor, 
+        return_grads: bool = False
+    ) -> torch.Tensor:
     """Return the diagonal Hessian of `out` with respect to `inp`.
 
     Args:
@@ -146,7 +148,9 @@ def __getitem__(self, index: int) -> torch.Tensor:
 
 class DataLoader:
     def __init__(
-        self, data: torch.Tensor, batch_size: int, pin_memory: bool = False
+        self, data: torch.Tensor, 
+        batch_size: int, 
+        pin_memory: bool = False
     ) -> None:
         """Simple DataLoader to replace torch data loader
 
@@ -196,8 +200,7 @@ def __next__(self) -> torch.Tensor:
             return out
         else:
             raise StopIteration
-
-
+        
 class OrthoReg(nn.Module):
     """add a penalty to make matrice orthgonal."""
 
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
index 1735eb3d..df95a16f 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_electron_distance.py
@@ -8,9 +8,12 @@
 
 
 class ElectronElectronDistance(nn.Module):
-    def __init__(
-        self, nelec: int, ndim: int = 3, scale: bool = False, scale_factor: float = 0.6
-    ) -> None:
+    def __init__(self, 
+                 nelec: int, 
+                 ndim: int = 3, 
+                 scale: bool = False,
+                 scale_factor: float = 0.6
+                 ) -> None:
         """Computes the electron-electron distances
 
         .. math::
@@ -44,7 +47,11 @@ def __init__(
         elif _type_ == torch.float64:
             self.eps = 1e-16
 
-    def forward(self, input: torch.Tensor, derivative: int = 0) -> torch.Tensor:
+    def forward(
+        self, 
+        input: torch.Tensor, 
+        derivative: int = 0
+    ) -> torch.Tensor:
         """Compute the pairwise distance between the electrons
         or its derivative.
 
@@ -59,14 +66,14 @@ def forward(self, input: torch.Tensor, derivative: int = 0) -> torch.Tensor:
             \\frac{d r_{ij}}{dx_j} = -\\frac{dr_{ij}}{dx_i}
 
         Args:
-            input (torch.Tensor): position of the electron
+            input (torch.Tensor): position of the electron 
                                   size : Nbatch x [Nelec x Ndim]
-            derivative (int, optional): degre of the derivative.
+            derivative (int, optional): degre of the derivative. 
                                         Defaults to 0.
 
         Returns:
-            torch.Tensor: distance (or derivative) matrix
-                          Nbatch x Nelec x Nelec if derivative = 0
+            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
 
         """
@@ -148,9 +155,7 @@ def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tenso
         diff_axis = diff_axis - diff_axis.transpose(2, 3)
         return diff_axis * invr
 
-    def get_second_der_distance(
-        self, pos: torch.Tensor, dist: torch.Tensor
-    ) -> torch.Tensor:
+    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::
diff --git a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
index 93029b9b..20b0cbee 100644
--- a/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
+++ b/qmctorch/wavefunction/jastrows/distance/electron_nuclei_distance.py
@@ -113,9 +113,7 @@ def get_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tenso
         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: torch.Tensor, dist: torch.Tensor
-    ) -> torch.Tensor:
+    def get_second_der_distance(self, pos: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
         """Get the derivative of the electron-nuclei distance matrix
 
         .. math::
@@ -139,9 +137,7 @@ def get_second_der_distance(
         return diff_axis * invr3
 
     @staticmethod
-    def _get_distance_quadratic(
-        elec_pos: torch.Tensor, atom_pos: torch.Tensor
-    ) -> torch.Tensor:
+    def _get_distance_quadratic(elec_pos: torch.Tensor, atom_pos: torch.Tensor) -> torch.Tensor:
         """Compute the distance following a quadratic expansion
 
         Arguments:
diff --git a/qmctorch/wavefunction/jastrows/distance/scaling.py b/qmctorch/wavefunction/jastrows/distance/scaling.py
index 1d20edf6..6c39e1c0 100644
--- a/qmctorch/wavefunction/jastrows/distance/scaling.py
+++ b/qmctorch/wavefunction/jastrows/distance/scaling.py
@@ -19,9 +19,7 @@ def get_scaled_distance(kappa: float, r: torch.Tensor) -> torch.Tensor:
     return (1.0 - torch.exp(-kappa * r)) / kappa
 
 
-def get_der_scaled_distance(
-    kappa: float, r: torch.Tensor, dr: torch.Tensor
-) -> torch.Tensor:
+def get_der_scaled_distance(kappa: float, r:torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
     """Returns the derivative of the scaled distances
 
     .. math::
@@ -41,9 +39,7 @@ def get_der_scaled_distance(
     return dr * torch.exp(-kappa * r.unsqueeze(1))
 
 
-def get_second_der_scaled_distance(
-    kappa: float, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-) -> torch.Tensor:
+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::
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 e272f6b6..e56a850d 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/jastrow_factor_electron_electron.py
@@ -3,12 +3,9 @@
 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 .kernels.jastrow_kernel_electron_electron_base import JastrowKernelElectronElectronBase
 from ....scf import Molecule
 
-
 class JastrowFactorElectronElectron(nn.Module):
     def __init__(
         self,
@@ -17,9 +14,9 @@ def __init__(
         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,
+        scale: Optional[bool]=False,
+        scale_factor: Optional[float]=0.6,
+        cuda: Optional[bool]=False,
     ) -> None:
         """Electron-Electron Jastrow factor.
 
@@ -142,9 +139,11 @@ def get_edist_unique(self, pos: torch.Tensor, derivative: int = 0) -> torch.Tens
                 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]]:
+    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:
@@ -195,9 +194,7 @@ def forward(
                 self.jastrow_factor_second_derivative(r, dr, d2r, jast),
             )
 
-    def jastrow_factor_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool
-    ) -> torch.Tensor:
+    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:
@@ -234,9 +231,7 @@ def jastrow_factor_derivative(
 
         return out
 
-    def jastrow_factor_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor, jast: torch.Tensor
-    ) -> torch.Tensor:
+    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:
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 87720aac..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
@@ -3,7 +3,6 @@
 from torch.autograd import grad
 from typing import Tuple
 
-
 class JastrowKernelElectronElectronBase(nn.Module):
     def __init__(self, nup: int, ndown: int, cuda: bool, **kwargs):
         r"""Base class for the elec-elec jastrow kernels
@@ -75,9 +74,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
 
@@ -122,9 +119,7 @@ def _grads(val, pos: torch.Tensor) -> torch.Tensor:
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(
-        val: torch.Tensor, pos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
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 707c2d84..edb1b8f6 100644
--- a/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
+++ b/qmctorch/wavefunction/jastrows/elec_elec/kernels/pade_jastrow_kernel.py
@@ -116,9 +116,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return a + b
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
 
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 79ef5b8d..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
@@ -6,15 +6,8 @@
 
 
 class PadeJastrowPolynomialKernel(JastrowKernelElectronElectronBase):
-    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:
+    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::
@@ -82,9 +75,7 @@ def get_static_weight(self) -> torch.Tensor:
 
         return static_weight
 
-    def set_variational_weights(
-        self, weight_a: Union[torch.Tensor, None], weight_b: Union[torch.Tensor, None]
-    ) -> None:
+    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:
@@ -180,9 +171,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return (der_num * denom - num * der_denom) / (denom * denom)
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
 
@@ -245,9 +234,7 @@ def _compute_polynoms(self, r: torch.Tensor) -> torch.Tensor:
 
         return num, denom
 
-    def _compute_polynom_derivatives(
-        self, r: torch.Tensor, dr: torch.Tensor
-    ) -> torch.Tensor:
+    def _compute_polynom_derivatives(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         """Computes the derivatives of the polynomials.
 
         Args:
@@ -276,9 +263,7 @@ def _compute_polynom_derivatives(
 
         return der_num, der_denom
 
-    def _compute_polynom_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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:
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 ab4eb1f8..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
@@ -5,19 +5,15 @@
 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,
-)
-
+from .kernels.jastrow_kernel_electron_electron_nuclei_base import JastrowKernelElectronElectronNucleiBase
 
 class JastrowFactorElectronElectronNuclei(nn.Module):
-    def __init__(
-        self,
-        mol: Molecule,
-        jastrow_kernel: JastrowKernelElectronElectronNucleiBase,
-        kernel_kwargs: Dict = {},
-        cuda: bool = False,
-    ) -> None:
+    def __init__(self, 
+                 mol: Molecule, 
+                 jastrow_kernel: JastrowKernelElectronElectronNucleiBase, 
+                 kernel_kwargs: Dict = {}, 
+                 cuda: bool = False
+                 ) -> None:
         """Jastrow Factor of the elec-elec-nuc term:
 
         .. math::
@@ -146,9 +142,7 @@ def assemble_dist(self, pos: torch.Tensor) -> torch.Tensor:
         # cat both
         return torch.cat((ren, ree), -1)
 
-    def assemble_dist_deriv(
-        self, pos: torch.Tensor, derivative: int = 1
-    ) -> torch.Tensor:
+    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}]
@@ -185,9 +179,7 @@ def _to_device(self) -> None:
             if at in self.__dict__:
                 self.__dict__[at] = self.__dict__[at].to(self.device)
 
-    def forward(
-        self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True
-    ) -> torch.Tensor:
+    def forward(self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Compute the Jastrow factors.
 
         Args:
@@ -252,9 +244,7 @@ def forward(
         else:
             raise ValueError("Derivative value nor recognized")
 
-    def jastrow_factor_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool
-    ) -> torch.Tensor:
+    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:
@@ -315,9 +305,12 @@ def jastrow_factor_derivative(
 
         return out
 
-    def jastrow_factor_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor, jast: torch.Tensor
-    ) -> torch.Tensor:
+    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:
@@ -379,9 +372,10 @@ def partial_derivative(self, djast: torch.Tensor) -> torch.Tensor:
 
         return ((out.sum(2)) ** 2).sum(1)
 
-    def jastrow_factor_second_derivative_auto(
-        self, pos: torch.Tensor, jast: Union[None, torch.Tensor] = None
-    ) -> torch.Tensor:
+    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
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 7969610a..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
@@ -7,8 +7,13 @@
 
 class BoysHandyJastrowKernel(JastrowKernelElectronElectronNucleiBase):
     def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, nterm: int = 5
-    ) -> None:  # pylint: disable=too-many-arguments
+        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
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 e7a015e8..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
@@ -5,9 +5,7 @@
 
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronElectronNucleiBase):
-    def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool
-    ) -> None:
+    def __init__(self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool)-> None:
         """Defines a fully connected jastrow factors.
 
         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 c2c316b3..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,9 +5,7 @@
 
 
 class JastrowKernelElectronElectronNucleiBase(nn.Module):
-    def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs
-    ) -> None:
+    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:
@@ -56,9 +54,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
         # sum over the atoms
         return out
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
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 e9c46e1d..621603b7 100644
--- a/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
+++ b/qmctorch/wavefunction/jastrows/elec_nuclei/jastrow_factor_electron_nuclei.py
@@ -5,15 +5,13 @@
 from ....scf import Molecule
 from .kernels.jastrow_kernel_electron_nuclei_base import JastrowKernelElectronNucleiBase
 
-
 class JastrowFactorElectronNuclei(nn.Module):
-    def __init__(
-        self,
-        mol: Molecule,
-        jastrow_kernel: JastrowKernelElectronNucleiBase,
-        kernel_kwargs: Dict = {},
-        cuda: bool = False,
-    ) -> None:
+    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::
@@ -57,12 +55,11 @@ 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]]:
+    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:
@@ -113,9 +110,7 @@ def forward(
                 self.jastrow_factor_second_derivative(r, dr, d2r, jast),
             )
 
-    def jastrow_factor_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, jast: torch.Tensor, sum_grad: bool
-    ) -> torch.Tensor:
+    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:
@@ -134,9 +129,12 @@ def jastrow_factor_derivative(
             djast = self.jastrow_kernel.compute_derivative(r, dr).sum(3)
             return djast * jast.unsqueeze(-1)
 
-    def jastrow_factor_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor, jast: torch.Tensor
-    ) -> torch.Tensor:
+    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:
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 8e96ecad..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
@@ -6,7 +6,12 @@
 
 class FullyConnectedJastrowKernel(JastrowKernelElectronNucleiBase):
     def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w: float = 1.0
+        self,
+        nup: int,
+        ndown: int,
+        atomic_pos: torch.Tensor,
+        cuda: bool,
+        w: float = 1.0
     ) -> None:
         r"""Computes the Simple Pade-Jastrow factor
 
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 e0c30a58..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
@@ -3,11 +3,8 @@
 from torch.autograd import grad
 from typing import Tuple
 
-
 class JastrowKernelElectronNucleiBase(nn.Module):
-    def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, **kwargs
-    ) -> None:
+    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::
@@ -80,9 +77,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return ker_grad.unsqueeze(1) * dr
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
 
@@ -133,9 +128,7 @@ def _grads(val: torch.Tensor, pos: torch.Tensor) -> torch.Tensor:
         return grad(val, pos, grad_outputs=torch.ones_like(val))[0]
 
     @staticmethod
-    def _hess(
-        val: torch.Tensor, pos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
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 bf909e52..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,9 +6,7 @@
 
 
 class PadeJastrowKernel(JastrowKernelElectronNucleiBase):
-    def __init__(
-        self, nup: int, ndown: int, atomic_pos: torch.Tensor, cuda: bool, w: float = 1.0
-    ) -> None:
+    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::
@@ -33,7 +31,7 @@ def __init__(
         self.static_weight = torch.as_tensor([1.0]).to(self.device)
         self.requires_autograd = True
 
-    def forward(self, r: torch.Tensor) -> torch.Tensor:
+    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}}
@@ -78,9 +76,7 @@ def compute_derivative(self, r: torch.Tensor, dr: torch.Tensor) -> torch.Tensor:
 
         return a + b
 
-    def compute_second_derivative(
-        self, r: torch.Tensor, dr: torch.Tensor, d2r: torch.Tensor
-    ) -> torch.Tensor:
+    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
 
diff --git a/qmctorch/wavefunction/jastrows/graph/__init__.py b/qmctorch/wavefunction/jastrows/graph/__init__.py
index 1bbde43d..5b9df08a 100644
--- a/qmctorch/wavefunction/jastrows/graph/__init__.py
+++ b/qmctorch/wavefunction/jastrows/graph/__init__.py
@@ -1,3 +1,3 @@
 from .mgcn_jastrow import MGCNJastrowFactor
 
-__all__ = ["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
index b462b5d0..f7d1467f 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_elec_graph.py
@@ -32,7 +32,7 @@ def get_elec_elec_edges(nelec: int) -> list:
     return ee_edges
 
 
-def get_elec_elec_ndata(nelec: int, nup: int) -> torch.Tensor:
+def get_elec_elec_ndata(nelec:int , nup: int) -> torch.Tensor:
     """Compute the node data of the elec-elec graph"""
 
     ee_ndata = []
diff --git a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
index 4efbc921..2d136a54 100644
--- a/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
+++ b/qmctorch/wavefunction/jastrows/graph/elec_nuc_graph.py
@@ -3,9 +3,7 @@
 from mendeleev import element
 
 
-def ElecNucGraph(
-    natoms: int, atom_types: list, atomic_features: list, nelec: int, nup: int
-) -> dgl.DGLGraph:
+def ElecNucGraph(natoms:int, atom_types:list, atomic_features:list, nelec:int, nup:int) -> dgl.DGLGraph:
     """Create the elec-nuc graph
 
     Args:
@@ -41,9 +39,7 @@ def get_elec_nuc_edges(natoms: int, nelec: int) -> tuple:
     return en_edges
 
 
-def get_elec_nuc_ndata(
-    natoms: int, atom_types: list, atomic_features: list, nelec: int, nup: int
-) -> torch.Tensor:
+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 = []
diff --git a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
index f1162109..40a896b9 100644
--- a/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
+++ b/qmctorch/wavefunction/jastrows/graph/mgcn_jastrow.py
@@ -11,7 +11,6 @@
 from .elec_nuc_graph import ElecNucGraph
 from ....scf import Molecule
 
-
 class MGCNJastrowFactor(nn.Module):
     def __init__(
         self,
@@ -84,9 +83,11 @@ 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]]:
+    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:
@@ -146,9 +147,7 @@ def forward(
                 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:
+    def _get_val(self, ee_kernel: torch.Tensor, en_kernel: torch.Tensor) -> torch.Tensor:
         """Get the jastrow values.
 
         Args:
@@ -157,13 +156,7 @@ def _get_val(
         """
         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:
+    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
 
 
@@ -187,12 +180,7 @@ def _get_grad_vals(
         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,
+        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
 
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals.py b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
index ea8428f3..1b375c58 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals.py
@@ -11,7 +11,6 @@
 from .spherical_harmonics import Harmonics
 from ...scf import Molecule
 
-
 class AtomicOrbitals(nn.Module):
     def __init__(self, mol: Molecule, cuda: Optional[bool] = False) -> None:
         """Computes the value of atomic orbitals
@@ -129,12 +128,12 @@ def _to_device(self) -> None:
             self.__dict__[at] = self.__dict__[at].to(self.device)
 
     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,
+        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.
 
@@ -248,9 +247,7 @@ def _ao_kernel(self, R: torch.Tensor, Y: torch.Tensor) -> torch.Tensor:
             ao = self._contract(ao)
         return ao
 
-    def _compute_first_derivative_ao_values(
-        self, pos: torch.Tensor, sum_grad: bool
-    ) -> torch.Tensor:
+    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:
@@ -287,9 +284,12 @@ def _compute_sum_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._sum_gradient_kernel(R, dR, Y, dY)
 
-    def _sum_gradient_kernel(
-        self, R: torch.Tensor, dR: torch.Tensor, Y: torch.Tensor, dY: torch.Tensor
-    ) -> torch.Tensor:
+    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:
@@ -327,9 +327,12 @@ def _compute_gradient_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._gradient_kernel(R, dR, Y, dY)
 
-    def _gradient_kernel(
-        self, R: torch.Tensor, dR: torch.Tensor, Y: torch.Tensor, dY: torch.Tensor
-    ) -> torch.Tensor:
+    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:
@@ -355,9 +358,7 @@ def _gradient_kernel(
             ao = bas
         return ao
 
-    def _compute_second_derivative_ao_values(
-        self, pos: torch.Tensor, sum_hess: bool
-    ) -> torch.Tensor:
+    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:
@@ -394,15 +395,14 @@ def _compute_sum_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor
         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: torch.Tensor,
-        dR: torch.Tensor,
-        d2R: torch.Tensor,
-        Y: torch.Tensor,
-        dY: torch.Tensor,
-        d2Y: torch.Tensor,
-    ) -> torch.Tensor:
+    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:
@@ -452,15 +452,14 @@ def _compute_diag_hessian_ao_values(self, pos: torch.Tensor) -> torch.Tensor:
 
         return self._diag_hessian_kernel(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:
+    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:
@@ -493,9 +492,7 @@ def _diag_hessian_kernel(
 
         return d2ao
 
-    def _compute_mixed_second_derivative_ao_values(
-        self, pos: torch.Tensor
-    ) -> torch.Tensor:
+    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:
diff --git a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
index 3bf73542..2f44fe13 100644
--- a/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
+++ b/qmctorch/wavefunction/orbitals/atomic_orbitals_backflow.py
@@ -4,14 +4,11 @@
 from ...scf import Molecule
 from .backflow.backflow_transformation import BackFlowTransformation
 
-
 class AtomicOrbitalsBackFlow(AtomicOrbitals):
-    def __init__(
-        self,
-        mol: Molecule,
-        backflow: BackFlowTransformation,
-        cuda: Optional[bool] = False,
-    ) -> None:
+    def __init__(self, 
+                 mol: Molecule, 
+                 backflow: BackFlowTransformation, 
+                 cuda: Optional[bool] = False) -> None:
         """Computes the value of atomic orbitals
 
         Args:
@@ -25,12 +22,12 @@ def __init__(
         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,
+        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.
 
@@ -117,9 +114,7 @@ def forward(
 
         return ao
 
-    def _compute_first_derivative_ao_values(
-        self, pos: torch.Tensor, sum_grad: bool
-    ) -> torch.Tensor:
+    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:
@@ -139,9 +134,10 @@ def _compute_first_derivative_ao_values(
 
         return grad
 
-    def _compute_gradient_backflow_ao_values(
-        self, pos: torch.Tensor, grad_ao: Optional[Union[None, torch.Tensor]] = None
-    ) -> torch.Tensor:
+    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:
@@ -177,9 +173,7 @@ def _compute_gradient_backflow_ao_values(
 
         return grad_ao
 
-    def _compute_second_derivative_ao_values(
-        self, pos: torch.Tensor, sum_hess: bool
-    ) -> torch.Tensor:
+    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:
@@ -200,11 +194,11 @@ def _compute_second_derivative_ao_values(
         return hess
 
     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,
+        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
 
@@ -262,9 +256,8 @@ def _compute_diag_hessian_backflow_ao_values(
 
         return hess_ao
 
-    def _compute_all_backflow_ao_values(
-        self, pos: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    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:
diff --git a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
index 319ea313..291761f8 100644
--- a/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/backflow_transformation.py
@@ -43,7 +43,10 @@ def __init__(
         if self.cuda:
             self.device = torch.device("cuda")
 
-    def forward(self, pos: torch.Tensor, derivative: Optional[int] = 0) -> torch.Tensor:
+    def forward(self, 
+                pos: torch.Tensor, 
+                derivative: Optional[int] = 0
+                ) -> torch.Tensor:
         if derivative == 0:
             return self._get_backflow(pos)
 
@@ -58,7 +61,9 @@ def forward(self, pos: torch.Tensor, derivative: Optional[int] = 0) -> torch.Ten
                 "derivative of the backflow transformation must be 0, 1 or 2"
             )
 
-    def _get_backflow(self, pos: torch.Tensor) -> torch.Tensor:
+    def _get_backflow(self, 
+                      pos: torch.Tensor
+                      ) -> torch.Tensor:
         """Computes the backflow transformation
 
         .. math:
@@ -235,7 +240,7 @@ def _backflow_derivative(self, pos: torch.Tensor) -> torch.Tensor:
 
         return out.unsqueeze(-1)
 
-    def _backflow_derivative_od(self, pos: torch.Tensor) -> torch.Tensor:
+    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
 
@@ -522,6 +527,7 @@ def _backflow_second_derivative_od(self, pos: torch.Tensor) -> torch.Tensor:
 
         return out.permute(0, 2, 3, 4, 5, 1)
 
+
     def __repr__(self):
         """representation of the backflow transformation"""
-        return self.backflow_kernel.__class__.__name__
+        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 4b03cf7d..249d814d 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/__init__.py
@@ -15,5 +15,5 @@
     "BackFlowKernelPowerSum",
     "BackFlowKernelSquare",
     "BackFlowKernelRBF",
-    "BackFlowKernelExp",
+    "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 7db1ad00..2b5f00e7 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_autodiff_inverse.py
@@ -3,7 +3,6 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
-
 class BackFlowKernelAutoInverse(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool, order: int = 2) -> None:
         """Compute the back flow kernel, i.e. the function
@@ -20,7 +19,7 @@ def __init__(self, mol: Molecule, cuda: bool, order: int = 2) -> None:
 
         self.weight = nn.Parameter(torch.as_tensor([1e-3]))
 
-    def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
+    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_base.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
index 22eb6243..5dde3648 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_base.py
@@ -4,7 +4,6 @@
 from typing import Tuple, List, Union
 from .....scf import Molecule
 
-
 class BackFlowKernelBase(nn.Module):
     def __init__(self, mol: Molecule, cuda: bool):
         """Compute the back flow kernel, i.e. the function
@@ -101,9 +100,7 @@ def _grad(val, ree: torch.Tensor) -> torch.Tensor:
         return grad(val, ree, grad_outputs=torch.ones_like(val), allow_unused=False)[0]
 
     @staticmethod
-    def _hess(
-        val, ree: torch.Tensor
-    ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+    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,15 +110,9 @@ def _hess(
             pos ([type]): [description]
         """
 
-        gval = grad(
-            val,
-            ree,
-            grad_outputs=torch.ones_like(val),
-            create_graph=True,
-            allow_unused=False,
-        )[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)
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
index db0e71c0..94fd9a33 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_exp.py
@@ -7,9 +7,7 @@
 
 
 class BackFlowKernelExp(BackFlowKernelBase):
-    def __init__(
-        self, mol: Molecule, cuda: bool = False, weight: float = 0.0, alpha: float = 1.0
-    ):
+    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
@@ -23,7 +21,7 @@ def __init__(
         """
         super().__init__(mol, cuda)
         self.weight = nn.Parameter(torch.as_tensor([weight]))  # .to(self.device)
-        self.alpha = nn.Parameter(torch.as_tensor([alpha]))
+        self.alpha = nn.Parameter(torch.as_tensor([alpha])) 
 
     def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         """Computes the backflow kernel:
@@ -57,8 +55,7 @@ def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
 
         # 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)
-
+        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}
@@ -74,4 +71,4 @@ def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
 
         # 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)
+        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 0cdc72f2..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,8 +1,7 @@
 import torch
 from torch import nn
 from .backflow_kernel_base import BackFlowKernelBase
-from .....scf import Molecule
-
+from.....scf import Molecule
 
 class BackFlowKernelFullyConnected(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool):
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 1371671a..6cd7ab4a 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_power_sum.py
@@ -3,7 +3,6 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
-
 class BackFlowKernelPowerSum(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool, order: int = 2):
         """Compute the back flow kernel, i.e. the function
diff --git a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
index 44ae9889..5887be77 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_rbf.py
@@ -6,9 +6,10 @@
 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
 
@@ -44,61 +45,59 @@ def __init__(self, mol: Molecule, cuda: bool = False, num_rbf: int = 10):
         self.sigma.requires_grad = True
 
         self.weight = nn.Parameter(torch.Tensor(num_rbf, 1))
-        self.weight.data.fill_(1.0)
+        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)
+        self.register_parameter('bias', None)
 
     def _gaussian_kernel(self, ree: torch.Tensor) -> torch.Tensor:
-        """Compute the RBF kernel
-
+        
+        '''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)
-
+        '''
+        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
-
+        '''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)
-
+        '''
+        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
-
+        '''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
-        )
+        return -2 / self.sigma * kernel  - 2*(ree-self.centers)/self.sigma * derivative
 
     def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
-        """Compute the kernel
-
+        '''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)
@@ -106,7 +105,7 @@ def _backflow_kernel(self, ree: torch.Tensor) -> torch.Tensor:
         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
 
@@ -120,7 +119,7 @@ def _backflow_kernel_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         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
 
@@ -134,3 +133,5 @@ def _backflow_kernel_second_derivative(self, ree: torch.Tensor) -> torch.Tensor:
         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 82974518..2d4a1e01 100644
--- a/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
+++ b/qmctorch/wavefunction/orbitals/backflow/kernels/backflow_kernel_square.py
@@ -3,7 +3,6 @@
 from .backflow_kernel_base import BackFlowKernelBase
 from .....scf import Molecule
 
-
 class BackFlowKernelSquare(BackFlowKernelBase):
     def __init__(self, mol: Molecule, cuda: bool = False):
         """Define a generic kernel to test the auto diff features."""
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
index 23045abe..ad5aaf4b 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_kernel.py
@@ -4,15 +4,12 @@
 from .kernels.backflow_kernel_base import BackFlowKernelBase
 from ....scf import Molecule
 
-
 class OrbitalDependentBackFlowKernel(nn.Module):
-    def __init__(
-        self,
-        backflow_kernel: BackFlowKernelBase,
-        backflow_kernel_kwargs: Dict,
-        mol: Molecule,
-        cuda: bool,
-    ) -> None:
+    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
diff --git a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
index b89b9612..b079c3ff 100644
--- a/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
+++ b/qmctorch/wavefunction/orbitals/backflow/orbital_dependent_backflow_transformation.py
@@ -6,15 +6,12 @@
 from .orbital_dependent_backflow_kernel import OrbitalDependentBackFlowKernel
 from ....scf import Molecule
 
-
 class OrbitalDependentBackFlowTransformation(nn.Module):
-    def __init__(
-        self,
-        mol: Molecule,
-        backflow_kernel: BackFlowKernelBase,
-        backflow_kernel_kwargs: Dict = {},
-        cuda: bool = 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
diff --git a/qmctorch/wavefunction/orbitals/norm_orbital.py b/qmctorch/wavefunction/orbitals/norm_orbital.py
index 8d371a8c..e251caf3 100644
--- a/qmctorch/wavefunction/orbitals/norm_orbital.py
+++ b/qmctorch/wavefunction/orbitals/norm_orbital.py
@@ -4,8 +4,7 @@
 from types import SimpleNamespace
 from ...utils.algebra_utils import double_factorial
 
-
-def atomic_orbital_norm(basis: SimpleNamespace) -> torch.Tensor:
+def atomic_orbital_norm(basis : SimpleNamespace) -> torch.Tensor:
     """Computes the norm of the atomic orbitals
 
     Args:
@@ -83,22 +82,20 @@ def norm_gaussian_spherical(bas_n: torch.Tensor, bas_exp: torch.Tensor) -> torch
     bas_n = bas_n + 1.0
     exp1 = 0.25 * (2.0 * bas_n + 1.0)
 
-    A = torch.tensor(bas_exp) ** exp1
-    B = 2 ** (2.0 * bas_n + 3.0 / 2)
-    C = torch.as_tensor(double_factorial(2 * bas_n.int() - 1) * np.pi**0.5).type(
-        torch.get_default_dtype()
-    )
+    A = torch.tensor(bas_exp)**exp1
+    B = 2**(2. * bas_n + 3. / 2)
+    C = torch.as_tensor(double_factorial(2 * bas_n.int() - 1) * np.pi **
+                        0.5).type(torch.get_default_dtype())
 
     return torch.sqrt(B / C) * A
 
 
-def norm_slater_cartesian(
-    a: torch.Tensor,
-    b: torch.Tensor,
-    c: torch.Tensor,
-    n: torch.Tensor,
-    exp: torch.Tensor,
-) -> torch.Tensor:
+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
 
@@ -112,7 +109,7 @@ def norm_slater_cartesian(
     Returns:
         torch.tensor: normalization factor
     """
-    lvals = a + b + c + n + 1.0
+    lvals = a + b + c + n + 1.
 
     lfact = torch.as_tensor([math.factorial(int(2 * i)) for i in lvals]).type(
         torch.get_default_dtype()
@@ -120,22 +117,23 @@ def norm_slater_cartesian(
 
     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)
-        * double_factorial(2 * c.astype("int") - 1)
-    ).type(torch.get_default_dtype())
+    num = torch.as_tensor(double_factorial(2 * a.astype('int') - 1) *
+                          double_factorial(2 * b.astype('int') - 1) *
+                          double_factorial(2 * c.astype('int') - 1)
+                          ).type(torch.get_default_dtype())
 
     denom = torch.as_tensor(
-        double_factorial((2 * a + 2 * b + 2 * c + 1).astype("int"))
-    ).type(torch.get_default_dtype())
+        double_factorial((2 * a + 2 * b + 2 * c + 1).astype('int')
+           )).type(torch.get_default_dtype())
 
     return torch.sqrt(1.0 / (prefact * num / denom))
 
 
-def norm_gaussian_cartesian(
-    a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, exp: torch.Tensor
-) -> torch.Tensor:
+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
 
@@ -148,14 +146,14 @@ def norm_gaussian_cartesian(
     Returns:
         torch.tensor: normalization factor
     """
-    pref = torch.as_tensor((2 * exp / np.pi) ** (0.75))
-    am1 = (2 * a - 1).astype("int")
-    x = (4 * exp) ** (a / 2) / torch.sqrt(torch.as_tensor(double_factorial(am1)))
+    pref = torch.as_tensor((2 * exp / np.pi)**(0.75))
+    am1 = (2 * a - 1).astype('int')
+    x = (4 * exp)**(a / 2) / torch.sqrt(torch.as_tensor(double_factorial(am1)))
 
-    bm1 = (2 * b - 1).astype("int")
-    y = (4 * exp) ** (b / 2) / torch.sqrt(torch.as_tensor(double_factorial(bm1)))
+    bm1 = (2 * b - 1).astype('int')
+    y = (4 * exp)**(b / 2) / torch.sqrt(torch.as_tensor(double_factorial(bm1)))
 
-    cm1 = (2 * c - 1).astype("int")
-    z = (4 * exp) ** (c / 2) / torch.sqrt(torch.as_tensor(double_factorial(cm1)))
+    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 e6df7658..ed0f39b3 100644
--- a/qmctorch/wavefunction/orbitals/radial_functions.py
+++ b/qmctorch/wavefunction/orbitals/radial_functions.py
@@ -245,7 +245,7 @@ def radial_gaussian_pure(
     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
+    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).
 
@@ -327,7 +327,7 @@ def radial_slater_pure(
     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
+    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).
 
diff --git a/qmctorch/wavefunction/orbitals/spherical_harmonics.py b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
index 0f2b42d4..7b63dab8 100644
--- a/qmctorch/wavefunction/orbitals/spherical_harmonics.py
+++ b/qmctorch/wavefunction/orbitals/spherical_harmonics.py
@@ -106,7 +106,7 @@ def CartesianHarmonics(
     mask2: torch.Tensor,
     derivative: list = [0],
     sum_grad: bool = True,
-    sum_hess: bool = True,
+    sum_hess: bool = True
 ) -> torch.Tensor:
     r"""Computes Real Cartesian Harmonics
 
@@ -244,9 +244,7 @@ def SphericalHarmonics(
         return get_grad_spherical_harmonics(xyz, l, m)
 
 
-def get_spherical_harmonics(
-    xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor, derivative: int
-):
+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:
@@ -305,9 +303,7 @@ def get_spherical_harmonics(
     return Y
 
 
-def get_grad_spherical_harmonics(
-    xyz: torch.Tensor, lval: torch.Tensor, m: torch.Tensor
-) -> torch.Tensor:
+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:
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index e7c891ec..b6322479 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -2,7 +2,6 @@
 from typing import Tuple, List
 from ...scf import Molecule
 
-
 class OrbitalConfigurations:
     def __init__(self, mol: Molecule) -> None:
         self.nup = mol.nup
@@ -83,9 +82,10 @@ def _get_ground_state_config(self) -> Tuple[torch.LongTensor, torch.LongTensor]:
         cup, cdown = [_gs_up], [_gs_down]
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_config(
-        self, nocc: Tuple[int, int], nvirt: Tuple[int, int]
-    ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -119,9 +119,10 @@ def _get_single_config(
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_single_double_config(
-        self, nocc: Tuple[int, int], nvirt: Tuple[int, int]
-    ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -172,9 +173,11 @@ def _get_single_double_config(
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_cas_config(
-        self, nocc: Tuple[int, int], nvirt: Tuple[int, int], nelec: int
-    ) -> Tuple[torch.LongTensor, torch.LongTensor]:
+    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:
@@ -208,9 +211,7 @@ def _get_cas_config(
 
         return (torch.LongTensor(cup), torch.LongTensor(cdown))
 
-    def _get_orb_number(
-        self, nelec: int, norb: int
-    ) -> Tuple[Tuple[int, int], Tuple[int, int]]:
+    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 ___
@@ -285,10 +286,7 @@ def _create_excitation_replace(conf: List[int], iocc: int, ivirt: int) -> List[i
 
     @staticmethod
     def _append_excitations(
-        cup: List[List[int]],
-        cdown: List[List[int]],
-        new_cup: List[int],
-        new_cdown: List[int],
+        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
 
diff --git a/qmctorch/wavefunction/pooling/orbital_projector.py b/qmctorch/wavefunction/pooling/orbital_projector.py
index 8e17d4ac..40560859 100644
--- a/qmctorch/wavefunction/pooling/orbital_projector.py
+++ b/qmctorch/wavefunction/pooling/orbital_projector.py
@@ -2,11 +2,11 @@
 from typing import List, Tuple
 from ...scf import Molecule
 
-
 class OrbitalProjector:
-    def __init__(
-        self, configs: List[torch.tensor], mol: Molecule, cuda: bool = False
-    ) -> None:
+    def __init__(self, 
+                 configs: List[torch.tensor], 
+                 mol: Molecule, 
+                 cuda: bool = False) -> None:
         """Project the MO matrix in Slater Matrices
 
         Args:
@@ -20,38 +20,31 @@ def __init__(
         self.nmo = mol.basis.nmo
         self.nup = mol.nup
         self.ndown = mol.ndown
-
+        
         self.device = torch.device("cpu")
         if cuda:
             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]]:
+    def get_unique_configs(self) -> Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]:
         """Get the unique configurations
 
         Returns:
-            Tuple[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor]]:
+            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
-        )
+        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)
+
+        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 (configs_up.to(self.device), configs_down.to(self.device)), (
-            index_unique_confs_up.to(self.device),
-            index_unique_confs_down.to(self.device),
-        )
 
     def split_orbitals(
-        self, mat: torch.Tensor, unique_configs: bool = False
+        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
@@ -66,34 +59,28 @@ def split_orbitals(
         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
-            )
+            out_down = torch.zeros(0, nbatch, self.ndown, self.ndown, device=self.device)
 
         if mat.ndim == 4:
             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:
+            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:
             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
-            )
+            out_down = torch.cat((out_down, mat[..., self.nup :, cdown].unsqueeze(0)), dim=0)
 
         return out_up, out_down
-
-
+        
 class ExcitationMask:
     def __init__(
         self,
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index 5a865cae..a03fdc73 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -103,11 +103,8 @@ def det_explicit(self, input: torch.Tensor) -> torch.Tensor:
         """
         mo_up, mo_down = self.get_slater_matrices(input)
         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)
+        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: torch.Tensor) -> torch.Tensor:
         """Computes the determinant of ground state + single + double excitations.
@@ -127,9 +124,7 @@ def det_single_double(self, input: torch.Tensor) -> torch.Tensor:
             * det_unique_down[:, self.index_unique_excitation[1]]
         )
 
-    def det_ground_state(
-        self, input: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    def det_ground_state(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Computes the Slater determinants of the ground state.
 
         Args:
@@ -143,9 +138,7 @@ def det_ground_state(
             torch.det(input[:, self.nup :, : self.ndown]),
         )
 
-    def det_unique_single_double(
-        self, input: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    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
@@ -283,6 +276,7 @@ def operator(
         if self.config_method == "ground_state":
             op_vals = self.operator_ground_state(mo, bop, op_squared)
 
+
         elif self.config_method.startswith("single"):
             if self.use_explicit_operator:
                 op_vals = self.operator_explicit(mo, bop, op_squared)
@@ -302,11 +296,11 @@ def operator(
             return op_vals
 
     def operator_ground_state(
-        self,
-        mo: torch.Tensor,
-        bop: torch.Tensor,
-        op_squared: bool = False,
-        inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+            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
 
@@ -431,11 +425,11 @@ def operator_single_double(
         )
 
     def operator_unique_single_double(
-        self,
-        mo: torch.Tensor,
-        bop: torch.Tensor,
-        op_squared: bool,
-        inv_mo: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+            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
 
@@ -460,11 +454,12 @@ def operator_unique_single_double(
         do_single = len(self.exc_mask.index_unique_single_up) != 0
         do_double = len(self.exc_mask.index_unique_double_up) != 0
 
-        # compute or retrieve the inverse of the up/down MO matrices
+        # 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]
@@ -506,8 +501,10 @@ def operator_unique_single_double(
             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:
+
             # reshape the M matrices
             Mup = Mup.view(*Mup.shape[:-2], -1)
             Mdown = Mdown.view(*Mdown.shape[:-2], -1)
@@ -565,6 +562,7 @@ def operator_unique_single_double(
         # if we want the squre of the operator
         # typically trace(ABAB)
         else:
+
             # compute A^-1 B M
             Yup = invAB_up @ Mup
             Ydown = invAB_down @ Mdown
@@ -603,6 +601,7 @@ def operator_unique_single_double(
                 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,
@@ -670,12 +669,12 @@ def op_single(
 
     @staticmethod
     def op_multiexcitation(
-        baseterm: torch.Tensor,
-        mat_exc: torch.Tensor,
+        baseterm: torch.Tensor, 
+        mat_exc: torch.Tensor, 
         M: torch.Tensor,
-        index: List[int],
-        size: int,
-        nbatch: int,
+        index: List[int], 
+        size: int, 
+        nbatch: int
     ) -> torch.Tensor:
         r"""Computes the operator values for single excitation
 
@@ -708,7 +707,7 @@ def op_multiexcitation(
         # computes T @ M (after reshaping M as size x size matrices)
         # THIS IS SURPRSINGLY THE COMPUTATIONAL BOTTLENECK
         m_tmp = M[..., index].view(_m_shape)
-        op_vals = T @ m_tmp
+        op_vals =  T @ m_tmp
 
         # compute the trace
         op_vals = btrace(op_vals)
@@ -725,7 +724,7 @@ def op_squared_single(
         M: torch.Tensor,
         Y: torch.Tensor,
         index: List[int],
-        nbatch: int,
+        nbatch: int
     ) -> torch.Tensor:
         r"""Computes the operator squared for single excitation
 
@@ -770,7 +769,7 @@ def op_squared_multiexcitation(
         Y: torch.tensor,
         index: List[int],
         size: int,
-        nbatch: int,
+        nbatch: int
     ) -> torch.tensor:
         r"""Computes the operator squared for multiple excitation
 
@@ -819,10 +818,12 @@ def op_squared_multiexcitation(
         op_vals += baseterm
 
         return op_vals
+    
 
-    def compute_inverse_occupied_mo_matrix(
-        self, mo: torch.Tensor
-    ) -> Union[Tuple[torch.Tensor, torch.Tensor], None]:
+    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:
@@ -833,13 +834,11 @@ def compute_inverse_occupied_mo_matrix(
         """
         # return None if we use the explicit calculation of all dets
         if self.config_method.startswith("cas("):
-            return None
-
+            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]),
-        )
+        return (torch.inverse(mo[:, : self.nup, : self.nup]), 
+                torch.inverse(mo[:, self.nup :, : self.ndown]))
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index cf4d2e0a..232d4aa6 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -1,11 +1,11 @@
 import torch
-from typing import Union, Optional, List
+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
+from torch.nn.utils.parametrizations import orthogonal 
 import operator
 import matplotlib.pyplot as plt
 
@@ -16,9 +16,7 @@
 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.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
@@ -26,20 +24,20 @@
 from .pooling.slater_pooling import SlaterPooling
 from .pooling.orbital_configurations import OrbitalConfigurations
 from ..utils import register_extra_attributes
-from ..utils.constants import BOHR2ANGS
+from ..utils.constants import BOHR2ANGS 
 
 
 class SlaterJastrow(WaveFunction):
     def __init__(
         self,
         mol: Molecule,
-        jastrow: Optional[Union[str, nn.Module, None]] = "default",
+        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,
-        orthogonalize_mo: bool = False,
+        orthogonalize_mo: bool = False
     ) -> None:
         """Slater Jastrow wave function with electron-electron Jastrow factor
 
@@ -120,7 +118,7 @@ def __init__(
 
         self.log_data()
 
-    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None]) -> None:
+    def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None])-> None:
         """Initialize the atomic orbital layer."""
         # self.backflow = backflow
         if backflow is None:
@@ -134,7 +132,7 @@ def init_atomic_orb(self, backflow: Union[BackFlowTransformation, None]) -> None
         if self.cuda:
             self.ao = self.ao.to(self.device)
 
-    def init_molecular_orb(self, include_all_mo: bool) -> None:
+    def init_molecular_orb(self, include_all_mo: bool)-> None:
         """initialize the molecular orbital layers"""
 
         # determine which orbs to include in the transformation
@@ -150,7 +148,7 @@ def init_molecular_orb(self, include_all_mo: bool) -> None:
         if self.cuda:
             self.mo_scf.to(self.device)
 
-    def init_mo_mixer(self, orthogonalize_mo: bool) -> None:
+    def init_mo_mixer(self, orthogonalize_mo: bool)-> None:
         """
         Initialize the molecular orbital mixing layer.
 
@@ -176,7 +174,7 @@ def init_mo_mixer(self, orthogonalize_mo: bool) -> None:
         if self.cuda:
             self.mo.to(self.device)
 
-    def init_config(self, configs: str) -> None:
+    def init_config(self, configs: str)-> None:
         """Initialize the electronic configurations desired in the wave function."""
 
         # define the SD we want
@@ -186,7 +184,7 @@ def init_config(self, configs: str) -> None:
         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:
+    def init_slater_det_calculator(self)-> None:
         """Initialize the calculator of the slater dets"""
 
         #  define the SD pooling layer
@@ -194,7 +192,7 @@ def init_slater_det_calculator(self) -> None:
             self.configs_method, self.configs, self.mol, self.cuda
         )
 
-    def init_fc_layer(self) -> None:
+    def init_fc_layer(self)-> None:
         """Init the fc layer"""
 
         # init the layer
@@ -221,10 +219,10 @@ def init_jastrow(self, jastrow: Union[str, nn.Module, None]) -> None:
             self.use_jastrow = True
 
             # create a simple Pade Jastrow factor as default
-            if jastrow == "default":
-                self.jastrow = JastrowFactorElectronElectron(
-                    self.mol, PadeJastrowKernel, cuda=self.cuda
-                )
+            if jastrow == 'default':
+                self.jastrow = JastrowFactorElectronElectron(self.mol, 
+                                                             PadeJastrowKernel, 
+                                                             cuda=self.cuda)
 
             elif isinstance(jastrow, list):
                 self.jastrow = CombineJastrow(jastrow)
@@ -233,7 +231,7 @@ def init_jastrow(self, jastrow: Union[str, nn.Module, None]) -> None:
                 self.jastrow = jastrow
 
             else:
-                raise TypeError("Jastrow factor not supported.")
+                raise TypeError('Jastrow factor not supported.')
 
             self.jastrow_type = self.jastrow.__repr__()
             if self.cuda:
@@ -243,9 +241,7 @@ 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:
+    def init_kinetic(self, kinetic: str, backflow: Union[BackFlowTransformation,None]) -> None:
         """ "Init the calculator of the kinetic energies"""
 
         self.kinetic_method = kinetic
@@ -258,9 +254,10 @@ def init_kinetic(
                 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:
+    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::
@@ -306,17 +303,16 @@ def forward(
         # if we do not have a Jastrow
         return self.fc(x)
 
-    def ao2mo(self, ao: torch.Tensor) -> torch.Tensor:
+    def ao2mo(self, ao:torch.Tensor) -> torch.Tensor:
         """transforms AO values in to MO values."""
 
         return self.mo(self.mo_scf(ao))
 
-    def pos2mo(
-        self,
-        x: torch.Tensor,
-        derivative: Optional[int] = 0,
-        sum_grad: Optional[bool] = True,
-    ) -> torch.Tensor:
+    def pos2mo(self, 
+               x: torch.Tensor, 
+               derivative: Optional[int] = 0, 
+               sum_grad: Optional[bool] = True
+               ) -> torch.Tensor:
         """Compute the MO vals from the pos
 
         Args:
@@ -365,12 +361,11 @@ def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         out = self.fc(kin * psi) / self.fc(psi)
         return out
 
-    def gradients_jacobi(
-        self,
-        x: torch.Tensor,
-        sum_grad: Optional[bool] = False,
-        pdf: Optional[bool] = False,
-    ) -> torch.Tensor:
+    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.
 
@@ -468,14 +463,13 @@ def gradients_jacobi(
 
         return out
 
-    def get_kinetic_operator(
-        self,
-        x: torch.Tensor,
-        ao: torch.Tensor,
-        dao: torch.Tensor,
-        d2ao: torch.Tensor,
-        mo: torch.Tensor,
-    ) -> torch.Tensor:
+    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:
@@ -538,45 +532,45 @@ def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Ten
         silent_timer = True
 
         # get ao values
-        with CodeTimer("Get AOs", silent=silent_timer):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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:
@@ -610,12 +604,10 @@ def kinetic_energy_jacobi_backflow(self, x: torch.Tensor, **kwargs) -> torch.Ten
         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,
-    ):
+    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:
@@ -663,9 +655,8 @@ def update_mo_coeffs(self) -> None:
         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:
+    def geometry(self, pos: torch.Tensor, 
+                 convert_to_angs: Optional[bool] = False) -> List:
         """Returns the gemoetry of the system in xyz format
 
         Args:
@@ -682,7 +673,7 @@ def geometry(
             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.
diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index dd2580ef..52f0e1c4 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -2,14 +2,12 @@
 import operator
 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.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,
 )
-from ..scf import Molecule
+from  ..scf import Molecule
 
 
 class SlaterOrbitalDependentJastrow(SlaterJastrow):
@@ -79,9 +77,7 @@ def __init__(
 
         self.log_data()
 
-    def ordered_jastrow(
-        self, pos: torch.Tensor, derivative: int = 0, sum_grad: bool = True
-    ) -> torch.Tensor:
+    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:
@@ -113,9 +109,7 @@ def permute(vals: torch.Tensor) -> torch.Tensor:
         else:
             return permute(jast_vals)
 
-    def forward(
-        self, x: torch.Tensor, ao: Union[torch.Tensor, None] = None
-    ) -> torch.Tensor:
+    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::
@@ -165,9 +159,7 @@ def ao2mo(self, ao: torch.Tensor) -> torch.Tensor:
     def ao2cmo(self, ao, jastrow):
         return jastrow * self.mo(self.mo_scf(ao))
 
-    def pos2mo(
-        self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True
-    ) -> torch.Tensor:
+    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)
@@ -176,9 +168,7 @@ def pos2mo(
         else:
             return self.ao2mo(ao.transpose(2, 3)).transpose(2, 3)
 
-    def pos2cmo(
-        self, x: torch.Tensor, derivative: int = 0, sum_grad: bool = True
-    ) -> torch.Tensor:
+    def pos2cmo(self, x: torch.Tensor, derivative:int = 0, sum_grad: bool = True) -> torch.Tensor:
         """Get the values of correlated MOs
 
         Arguments:
@@ -274,9 +264,7 @@ def kinetic_energy_jacobi(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
         # assemble
         return self.fc(kin * slater_dets) / self.fc(slater_dets)
 
-    def gradients_jacobi(
-        self, x: torch.Tensor, sum_grad: bool = True, pdf: bool = False
-    ) -> torch.Tensor:
+    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:
diff --git a/qmctorch/wavefunction/wf_base.py b/qmctorch/wavefunction/wf_base.py
index cc9bd121..b70ffccc 100644
--- a/qmctorch/wavefunction/wf_base.py
+++ b/qmctorch/wavefunction/wf_base.py
@@ -5,9 +5,7 @@
 
 
 class WaveFunction(torch.nn.Module):
-    def __init__(
-        self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False
-    ):
+    def __init__(self, nelec: int, ndim: int, kinetic: str = "auto", cuda: bool = False):
         """
         Base class for wave functions.
 
@@ -115,9 +113,10 @@ def nuclear_repulsion(self) -> torch.Tensor:
                 vnn += Z0 * Z1 / rnn
         return vnn
 
-    def gradients_autograd(
-        self, pos: torch.Tensor, pdf: Optional[bool] = False
-    ) -> torch.Tensor:
+    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.
 
@@ -202,7 +201,7 @@ def local_energy(self, pos: torch.Tensor) -> torch.Tensor:
             + self.nuclear_repulsion()
         )
 
-    def energy(self, pos: torch.Tensor) -> torch.Tensor:
+    def energy(self, pos:torch.Tensor) -> torch.Tensor:
         """Total energy for the sampling points."""
         return torch.mean(self.local_energy(pos))
 
@@ -226,9 +225,7 @@ def _energy_variance_error(self, pos: torch.Tensor) -> torch.Tensor:
         el = self.local_energy(pos)
         return torch.mean(el), torch.var(el), self.sampling_error(el)
 
-    def pdf(
-        self, pos: torch.Tensor, return_grad: Optional[bool] = False
-    ) -> torch.Tensor:
+    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)
@@ -242,12 +239,10 @@ def get_number_parameters(self) -> int:
                 nparam += param.data.numel()
         return nparam
 
-    def load(
-        self,
-        filename: str,
-        group: Optional[str] = "wf_opt",
-        model: Optional[str] = "best",
-    ):
+    def load(self, 
+             filename: str, 
+             group: Optional[str] = "wf_opt", 
+             model: Optional[str] = "best"):
         """Load trained parameters
 
         Args:
diff --git a/setup.py b/setup.py
index 2e461ceb..7a354a1c 100644
--- a/setup.py
+++ b/setup.py
@@ -2,74 +2,54 @@
 
 import os
 
-from setuptools import find_packages, setup
+from setuptools import (find_packages, setup)
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 # To update the package version number, edit QMCTorch/__version__.py
 version = {}
-with open(os.path.join(here, "qmctorch", "__version__.py")) as f:
+with open(os.path.join(here, 'qmctorch', '__version__.py')) as f:
     exec(f.read(), version)
 
-with open("README.md") as readme_file:
+with open('README.md') as readme_file:
     readme = readme_file.read()
 
 setup(
-    name="qmctorch",
-    version=version["__version__"],
+    name='qmctorch',
+    version=version['__version__'],
     description="Pytorch Implementation of Quantum Monte Carlo",
-    long_description=readme + "\n\n",
-    long_description_content_type="text/markdown",
+    long_description=readme + '\n\n',
+    long_description_content_type='text/markdown',
     author=["Nicolas Renaud", "Felipe Zapata"],
-    author_email="n.renaud@esciencecenter.nl",
-    url="https://github.com/NLESC-JCER/QMCTorch",
+    author_email='n.renaud@esciencecenter.nl',
+    url='https://github.com/NLESC-JCER/QMCTorch',
     packages=find_packages(),
-    package_dir={"qmctorch": "qmctorch"},
+    package_dir={'qmctorch': 'qmctorch'},
     include_package_data=True,
     license="Apache Software License 2.0",
     zip_safe=False,
-    keywords="qmctorch",
-    scripts=["bin/qmctorch"],
+    keywords='qmctorch',
+    scripts=['bin/qmctorch'],
     classifiers=[
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Science/Research",
-        "License :: OSI Approved :: Apache Software License",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Topic :: Scientific/Engineering :: Chemistry",
-    ],
-    test_suite="tests",
-    install_requires=[
-        "matplotlib",
-        "numpy",
-        "argparse",
-        "scipy",
-        "tqdm",
-        "torch",
-        "h5py",
-        "plams",
-        "pints",
-        "linetimer",
-        "pyscf",
-        "mendeleev",
-        "twiggy",
-        "plams",
-        "ase",
-        "rdkit",
-        "dgllife",
-        "dgl",
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: Apache Software License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Topic :: Scientific/Engineering :: Chemistry'
     ],
+    test_suite='tests',
+    install_requires=['matplotlib', 'numpy', 'argparse',
+                      'scipy', 'tqdm', 'torch', 'h5py',
+                      'plams', 'pints', 'linetimer',
+                      'pyscf', 'mendeleev', 'twiggy',
+                      'plams', 'ase', 'rdkit', 'dgllife', 'dgl'],
+
     extras_require={
-        "hpc": ["horovod"],
-        "doc": [
-            "recommonmark",
-            "sphinx",
-            "sphinx_rtd_theme",
-            "nbsphinx",
-            "nbconvert",
-            "jupyter",
-        ],
-        "test": ["pytest", "pytest-runner", "coverage", "coveralls", "pycodestyle"],
-    },
+        '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
index 82f2f482..aa4c6e7b 100644
--- a/tests/ase/test_ase_calc.py
+++ b/tests/ase/test_ase_calc.py
@@ -1,37 +1,36 @@
 import unittest
 
-from qmctorch.ase import QMCTorch
+from qmctorch.ase import QMCTorch     
 from qmctorch.ase.optimizer import TorchOptimizer
-from ase import Atoms
+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)])
+        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"
+        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.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}
+        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.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
@@ -40,10 +39,10 @@ def setUp(self):
         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"
+        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.mode = 'update'
         self.h2.calc.solver_options.resampling.resample_every = 1
         self.h2.calc.solver_options.resampling.ntherm_update = 10
 
@@ -51,21 +50,19 @@ def setUp(self):
         self.h2.calc.initialize()
 
     def test_calculate_energy(self):
-        self.h2.calc.calculate(properties=["energy"])
+        self.h2.calc.calculate(properties=['energy'])
 
     def test_calculate_forces(self):
-        self.h2.calc.calculate(properties=["forces"])
+        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 = 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 = FIRE(self.h2, trajectory='traj.xyz')
         dyn.run(fmax=0.005, steps=2)
diff --git a/tests/solver/test_base_solver.py b/tests/solver/test_base_solver.py
index 8ac9b6c7..6611f02c 100644
--- a/tests/solver/test_base_solver.py
+++ b/tests/solver/test_base_solver.py
@@ -1,7 +1,6 @@
 import unittest
 import numpy as np
 
-
 class BaseTestSolvers:
     class BaseTestSolverMolecule(unittest.TestCase):
         def setUp(self):
@@ -16,36 +15,36 @@ def setUp(self):
 
         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
+            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)
+            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
+            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)
+            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
+            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)
+            batchsize = int(self.solver.sampler.walkers.nwalkers/2) 
             _ = self.solver.run(5, batchsize=batchsize)
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 a706545c..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
@@ -4,12 +4,8 @@
 import torch
 from torch.autograd import Variable, grad
 
-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.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
 
 set_torch_double_precision()
@@ -18,16 +14,21 @@
 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,7 +36,9 @@ def hess(out, pos):
 
 
 class TestGenericJastrowOrbital(unittest.TestCase):
+
     def setUp(self):
+
         torch.manual_seed(0)
         np.random.seed(0)
 
@@ -47,11 +50,11 @@ def setUp(self):
             self.mol,
             FullyConnectedJastrowKernel,
             orbital_dependent_kernel=True,
-            number_of_orbitals=self.nmo,
+            number_of_orbitals=self.nmo
         )
         self.nbatch = 11
 
-        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):
@@ -63,25 +66,31 @@ 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.reshape(self.nbatch, self.nelec, 3).permute(0, 2, 1)
+        dval_grad = dval_grad.reshape(
+            self.nbatch, self.nelec, 3).permute(0, 2, 1)
 
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
         # modules in the list !
-        assert torch.allclose(dval.sum(0), dval_grad)
+        assert(torch.allclose(dval.sum(0), 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 = 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)
-        )
+        dval_grad = dval_grad.reshape(
+            self.nbatch, self.nelec, 3).permute(0, 2, 1).sum(-2)
 
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
@@ -89,6 +98,7 @@ def test_jacobian_jastrow(self):
         assert torch.allclose(dval.sum(0), 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)
@@ -96,9 +106,8 @@ def test_hess_jastrow(self):
         # Warning : using grad on a model made out of ModuleList
         # automatically summ the values of the grad of the different
         # modules in the list !
-        assert torch.allclose(
-            d2val.sum(0), d2val_grad.reshape(self.nbatch, self.nelec, 3).sum(2)
-        )
+        assert torch.allclose(d2val.sum(0), d2val_grad.reshape(
+            self.nbatch, self.nelec, 3).sum(2))
 
 
 if __name__ == "__main__":
diff --git a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
index 6ade78ee..697af246 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_generic_jastrow.py
@@ -6,12 +6,8 @@
 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.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
 
 set_torch_double_precision()
diff --git a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
index 0c6128a8..7d69096b 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow.py
@@ -4,12 +4,8 @@
 
 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.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
 
 set_torch_double_precision()
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 155d4df3..d9144999 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_pade_jastrow_polynom.py
@@ -6,12 +6,8 @@
 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.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
 
 set_torch_double_precision()
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 b361fcd8..e5fb91da 100644
--- a/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
+++ b/tests/wavefunction/jastrows/elec_elec/test_scaled_pade_jastrow.py
@@ -5,12 +5,8 @@
 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.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
 
 set_torch_double_precision()
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 d7f57bb3..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
@@ -5,12 +5,8 @@
 
 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.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
 
 set_torch_double_precision()
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 a1a3b951..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
@@ -3,12 +3,8 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import (
-    BoysHandyJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.boys_handy_jastrow_kernel import BoysHandyJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 d499d017..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
@@ -3,12 +3,8 @@
 import numpy as np
 import torch
 from torch.autograd import Variable, grad
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import (
-    JastrowFactorElectronElectronNuclei,
-)
-from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import (
-    FullyConnectedJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.jastrow_factor_electron_electron_nuclei import JastrowFactorElectronElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_elec_nuclei.kernels.fully_connected_jastrow_kernel import FullyConnectedJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 cacf5d1f..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
@@ -3,12 +3,8 @@
 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 import (
-    FullyConnectedJastrowKernel,
-)
+from qmctorch.wavefunction.jastrows.elec_nuclei.jastrow_factor_electron_nuclei import JastrowFactorElectronNuclei
+from qmctorch.wavefunction.jastrows.elec_nuclei.kernels import FullyConnectedJastrowKernel
 from qmctorch.utils import set_torch_double_precision
 
 set_torch_double_precision()
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 72a28bd4..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
@@ -3,12 +3,8 @@
 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.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
 
 set_torch_double_precision()
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_base.py b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
index 6c34d0c4..1ca1d221 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_base.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_base.py
@@ -4,7 +4,6 @@
 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)
@@ -45,21 +44,21 @@ def hess_single_element(out, inp):
 
     return hess.reshape(*shape)
 
-
 class BaseTestCases:
     class TestBackFlowKernelBase(unittest.TestCase):
-        def setUp(self):
-            pass
 
+        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_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())
@@ -244,17 +243,13 @@ def test_backflow_derivative(self):
             for iq in range(nao):
                 qao = q[:, iq, ...]
                 dqao = grad(
-                    qao,
-                    self.pos,
-                    grad_outputs=torch.ones_like(self.pos),
-                    retain_graph=True,
+                    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,
+                        (dq_grad, dqao), axis=self.backflow_trans.backflow_kernel.stack_axis
                     )
             # checksum
             assert torch.allclose(dq.sum(), dq_grad.sum())
@@ -299,4 +294,4 @@ def test_backflow_second_derivative(self):
             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)
+            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
index bbf45046..cd5736f0 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_exp_pyscf.py
@@ -6,12 +6,9 @@
 
 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.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)
@@ -35,6 +32,5 @@ def setUp(self):
         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 a341ef84..b4fc52d6 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_generic_pyscf.py
@@ -7,12 +7,9 @@
 
 from qmctorch.scf import Molecule
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelBase
-from qmctorch.wavefunction.jastrows.distance.electron_electron_distance import (
-    ElectronElectronDistance,
-)
+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()
 
 torch.manual_seed(101)
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 4eed0c4a..1a19d8eb 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_kernel_inverse_pyscf.py
@@ -6,18 +6,14 @@
 
 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.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
@@ -35,6 +31,5 @@ def setUp(self):
         self.pos = Variable(self.pos)
         self.pos.requires_grad = True
 
-
 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 101c618e..8457643c 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_pyscf.py
@@ -10,13 +10,15 @@
 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)
 
 
+
+
+
 class TestBackFlowTransformation(BaseTestCases.TestBackFlowTransformationBase):
     def setUp(self):
         # define the molecule
diff --git a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
index 573dc983..91983227 100644
--- a/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
+++ b/tests/wavefunction/orbitals/backflow/test_backflow_transformation_rbf_pyscf.py
@@ -10,13 +10,13 @@
 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
@@ -33,6 +33,5 @@ def setUp(self):
         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 63e454a7..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
@@ -10,16 +10,13 @@
 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)
 
 
-class TestOrbitalDependentBackFlowTransformation(
-    BaseTestCases.TestOrbitalDependentBackFlowTransformationBase
-):
+class TestOrbitalDependentBackFlowTransformation(BaseTestCases.TestOrbitalDependentBackFlowTransformationBase):
     def setUp(self):
         # define the molecule
         at = "C 0 0 0"
diff --git a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
index 9553333e..98bf9e20 100644
--- a/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
+++ b/tests/wavefunction/orbitals/test_ao_derivatives_adf.py
@@ -9,7 +9,6 @@
 
 set_torch_double_precision()
 
-
 class TestAOderivativesADF(BaseTestAO.BaseTestAOderivatives):
     def setUp(self):
         # define the molecule
diff --git a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
index a846b5f9..9dea37e2 100644
--- a/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
+++ b/tests/wavefunction/orbitals/test_backflow_ao_derivatives_pyscf.py
@@ -12,7 +12,6 @@
 )
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 torch.manual_seed(101)
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 db4ab45d..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
@@ -12,7 +12,6 @@
 )
 from qmctorch.wavefunction.orbitals.backflow.kernels import BackFlowKernelInverse
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 torch.manual_seed(101)
diff --git a/tests/wavefunction/test_compare_slaterjastrow_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
index f0e41c51..64d8e722 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_backflow.py
@@ -18,10 +18,8 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
-
 class TestCompareSlaterJastrowBackFlow(unittest.TestCase):
     def setUp(self):
         torch.manual_seed(101)
diff --git a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
index 194ac937..8f38ad66 100644
--- a/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_compare_slaterjastrow_orbital_dependent_backflow.py
@@ -17,7 +17,6 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
index 3518f82b..4278eb6c 100644
--- a/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
+++ b/tests/wavefunction/test_slater_orbital_dependent_jastrow.py
@@ -11,7 +11,6 @@
 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)
@@ -29,9 +28,7 @@ def setUp(self):
         )
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(
-            mol, PadeJastrowKernel, orbital_dependent_kernel=True
-        )
+        jastrow = JastrowFactorElectronElectron(mol, PadeJastrowKernel, orbital_dependent_kernel=True)
 
         self.wf = SlaterJastrow(
             mol,
@@ -60,6 +57,5 @@ def test_kinetic_energy(self):
     def test_local_energy(self):
         pass
 
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/wavefunction/test_slatercombinedjastrow_backflow.py b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
index 15eb18ce..018fff97 100644
--- a/tests/wavefunction/test_slatercombinedjastrow_backflow.py
+++ b/tests/wavefunction/test_slatercombinedjastrow_backflow.py
@@ -28,7 +28,6 @@
 )
 
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_backflow.py b/tests/wavefunction/test_slaterjastrow_backflow.py
index 186ae8d8..8afb6c50 100644
--- a/tests/wavefunction/test_slaterjastrow_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_backflow.py
@@ -14,7 +14,6 @@
     BackFlowKernelInverse,
 )
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 
diff --git a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
index 227d83b5..b391e6b7 100644
--- a/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
+++ b/tests/wavefunction/test_slaterjastrow_orbital_dependent_backflow.py
@@ -19,7 +19,6 @@
     BackFlowKernelInverse,
 )
 from qmctorch.utils import set_torch_double_precision
-
 set_torch_double_precision()
 
 
diff --git a/tests_hvd/test_h2_hvd.py b/tests_hvd/test_h2_hvd.py
index 3132514e..e50a2ae4 100644
--- a/tests_hvd/test_h2_hvd.py
+++ b/tests_hvd/test_h2_hvd.py
@@ -10,15 +10,14 @@
 from qmctorch.solver import SolverMPI
 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.jastrow_factor_electron_electron import JastrowFactorElectronElectron
 from qmctorch.wavefunction.jastrows.elec_elec.kernels import PadeJastrowKernel
 
 from qmctorch.utils import set_torch_double_precision
 
 
 class TestH2Hvd(unittest.TestCase):
+
     def setUp(self):
         hvd.init()
 
@@ -33,21 +32,22 @@ 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',
             rank=hvd.local_rank(),
-            mpi_size=hvd.local_size(),
-        )
+            mpi_size=hvd.local_size())
 
         # define jastrow factor
-        jastrow = JastrowFactorElectronElectron(self.mol, PadeJastrowKernel)
+        jastrow = JastrowFactorElectronElectron(
+            self.mol, PadeJastrowKernel)
 
         # wave function
-        self.wf = SlaterJastrow(
-            self.mol, kinetic="jacobi", configs="cas(2,2)", jastrow=jastrow, cuda=False
-        )
+        self.wf = SlaterJastrow(self.mol, kinetic='jacobi',
+                                configs='cas(2,2)',
+                                jastrow=jastrow,
+                                cuda=False)
 
         # sampler
         self.sampler = Metropolis(
@@ -56,17 +56,17 @@ def setUp(self):
             step_size=0.2,
             ndim=self.wf.ndim,
             nelec=self.wf.nelec,
-            init=self.mol.domain("atomic"),
-            move={"type": "all-elec", "proba": "normal"},
-        )
+            init=self.mol.domain('atomic'),
+            move={
+                'type': 'all-elec',
+                'proba': 'normal'})
 
         # optimizer
         self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
 
         # solver
-        self.solver = SolverMPI(
-            wf=self.wf, sampler=self.sampler, optimizer=self.opt, rank=hvd.rank()
-        )
+        self.solver = SolverMPI(wf=self.wf, sampler=self.sampler,
+                                                 optimizer=self.opt, rank=hvd.rank())
 
         # ground state energy
         self.ground_state_energy = -1.16
@@ -92,20 +92,17 @@ def test_wf_opt(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.configure(
-            track=["local_energy"],
-            freeze=["ao", "mo"],
-            loss="energy",
-            grad="auto",
-            ortho_mo=False,
-            clip_loss=False,
-            resampling={"mode": "update", "resample_every": 1, "nstep_update": 50},
-        )
+        self.solver.configure(track=['local_energy'], freeze=['ao', 'mo'],
+                              loss='energy', grad='auto',
+                              ortho_mo=False, clip_loss=False,
+                              resampling={'mode': 'update',
+                                          'resample_every': 1,
+                                          'nstep_update': 50})
         self.solver.run(10)
 
         MPI.COMM_WORLD.barrier()
 
-        self.solver.wf.load(self.solver.hdf5file, "wf_opt")
+        self.solver.wf.load(self.solver.hdf5file, 'wf_opt')
         self.solver.wf.eval()
 
         obs = self.solver.single_point()

From 5a6c9cd9c5f87b33639f0b9a3d5d308458392fc4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Mar 2025 18:06:01 +0100
Subject: [PATCH 264/286] added log loss

---
 docs/example/optimization/h2.py | 24 ++++++++++++--
 qmctorch/solver/solver.py       | 57 +++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/docs/example/optimization/h2.py b/docs/example/optimization/h2.py
index 0cad3b36..a9e49c2f 100644
--- a/docs/example/optimization/h2.py
+++ b/docs/example/optimization/h2.py
@@ -63,15 +63,35 @@
 # configure the solver
 solver.configure(track=['local_energy', 'parameters'], freeze=['ao'],
                  loss='energy', grad='manual',
-                 ortho_mo=False, clip_loss=True, clip_threshold=2,
+                 ortho_mo=False, clip_loss=False, clip_threshold=2,
                  resampling={'mode': 'update',
                              'resample_every': 1,
                              '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(5)  # , batchsize=10)
+# obs = solver.run(5)  # , batchsize=10)
 
 # plot
 # plot_energy(obs.local_energy, e0=-1.1645, show_variance=True)
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 9cf637a7..31c5583a 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -454,6 +454,63 @@ def evaluate_grad_manual_2(self, lpos):
         else:
             raise ValueError("Manual gradient only for energy minimization")
 
+    def evaluate_grad_manual_3(self, lpos):
+        """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 *= 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 log_data_opt(self, nepoch, task):
         """Log data for the optimization."""
         log.info("")

From 6dd312da572f985d7fedd2820a7106f1ea8325dc Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 4 Mar 2025 18:06:52 +0100
Subject: [PATCH 265/286] made log loss default

---
 qmctorch/solver/solver.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 31c5583a..a6944ab4 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -77,7 +77,7 @@ def configure(  # pylint: disable=too-many-arguments
             self.grad_method = grad
             self.evaluate_gradient = {
                 "auto": self.evaluate_grad_auto,
-                "manual": self.evaluate_grad_manual,
+                "manual": self.evaluate_grad_manual_3,
             }[grad]
 
         # resampling of the wave function

From a76c86e3c069ae58dff06fe6aff36d7eb6e92ab6 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 11 Mar 2025 18:31:47 +0100
Subject: [PATCH 266/286] introduce symmetry

---
 docs/example/ase/H2.xyz                 |   4 +
 docs/example/ase/h2.py                  |  34 ++++--
 docs/example/ase/tmp_79_iqdx            | Bin 0 -> 10528 bytes
 qmctorch/ase/ase.py                     |  11 +-
 qmctorch/ase/symmetry.py                | 153 ++++++++++++++++++++++++
 qmctorch/sampler/metropolis.py          |  11 +-
 qmctorch/scf/molecule.py                |   1 +
 qmctorch/solver/solver.py               |   4 +-
 qmctorch/wavefunction/slater_jastrow.py |   6 +-
 9 files changed, 210 insertions(+), 14 deletions(-)
 create mode 100644 docs/example/ase/H2.xyz
 create mode 100644 docs/example/ase/tmp_79_iqdx
 create mode 100644 qmctorch/ase/symmetry.py

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/h2.py b/docs/example/ase/h2.py
index b367b48c..ab6b2c5f 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,5 +1,6 @@
 from qmctorch.ase import QMCTorch     
 from qmctorch.ase.optimizer import TorchOptimizer
+from qmctorch.ase.symmetry import Cinfv
 from ase import Atoms 
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
@@ -21,21 +22,22 @@
 
 # WF options
 # h2.calc.wf_options.configs = 'ground_state'
-h2.calc.wf_options.configs = 'single_double(2,2)'
+h2.calc.wf_options.configs = 'single_double(2,4)'
 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 = 100
-h2.calc.sampler_options.nstep  = 5000
+h2.calc.sampler_options.nstep  = 500
 h2.calc.sampler_options.step_size = 0.5
-h2.calc.sampler_options.ntherm = 4000
+h2.calc.sampler_options.ntherm = 400
 h2.calc.sampler_options.ndecor = 10
+h2.calc.sampler_options.symmetry = Cinfv(axis='z')
 
 # solver options
 h2.calc.solver_options.freeze = []
-h2.calc.solver_options.niter = 10
+h2.calc.solver_options.niter = 0
 h2.calc.solver_options.tqdm = True
 h2.calc.solver_options.grad = 'manual'
 
@@ -44,15 +46,33 @@
 h2.calc.solver_options.resampling.resample_every = 1
 h2.calc.solver_options.resampling.ntherm_update = 100
 
+
 # Optimize the wave function
 h2.calc.initialize()
 
+print(h2.calc.wf.mo_scf.weight.data)
+print(h2.calc.wf.ao.bas_exp.data)
+mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
+# compute forces
+h2.get_forces()
+# h2.get_potential_energy()
+
+
+pos = torch.rand(2,6)
+sym_pos = h2.calc.sampler.symmetry(pos)
+h2.calc.wf.fc.weight.data = torch.rand(1, 16)
+print(h2.calc.wf.local_energy(pos))
+print(h2.calc.wf.local_energy(sym_pos))
+
+
+print(mo_init - h2.calc.wf.mo_scf.weight.data)
+
 # use torch optim for the optimization
 # dyn = TorchOptimizer(h2, 
 #                      trajectory='traj.xyz', 
 #                      nepoch_wf_init=50, 
 #                      nepoch_wf_update=15, 
 #                      tqdm=True)
-dyn = FIRE(h2, trajectory='traj.xyz')
-dyn.run(fmax=0.005, steps=5)
-write('final.xyz',h2)
+# dyn = FIRE(h2, trajectory='traj.xyz')
+# dyn.run(fmax=0.005, steps=5)
+# write('final.xyz',h2)
diff --git a/docs/example/ase/tmp_79_iqdx b/docs/example/ase/tmp_79_iqdx
new file mode 100644
index 0000000000000000000000000000000000000000..44d5155ede99d06accd885da626f430e1e1488f3
GIT binary patch
literal 10528
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

literal 0
HcmV?d00001

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 4dd9a0b6..e773ace3 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -5,6 +5,7 @@
 from torch import optim
 from types import SimpleNamespace
 
+from .symmetry import BaseSymmetry
 from ..utils import set_torch_double_precision
 from ..utils.constants import ANGS2BOHR
 from ..scf.molecule import Molecule as SCF
@@ -82,9 +83,11 @@ def __init__(self,
         # default option for the sampler
         self.sampler = None
         self.sampler_options = SimpleNamespace(nwalkers=4000, nstep=2000, 
-                                               ntherm=-1, ndecor=1, step_size=0.05)
+                                               ntherm=-1, ndecor=1, step_size=0.05,
+                                               symmetry=None)
         self.recognized_sampler_options = list(self.sampler_options.__dict__.keys())
         
+        
         # optimizer .... 
         self.optimizer = None
 
@@ -228,7 +231,8 @@ def set_sampler(self):
         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'), cuda=self.use_cuda)
+                                  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):
         if self.wf is None:
@@ -236,6 +240,7 @@ def set_default_optimizer(self):
         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.mo_scf.parameters(), 'lr': 1E-2},
                 {'params': self.wf.fc.parameters(), 'lr': 1E-2}]
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
@@ -450,6 +455,7 @@ def _calculate_energy(self, atoms=None):
         # 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 
@@ -484,6 +490,7 @@ def _calculate_forces(self, atoms=None):
         # 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
diff --git a/qmctorch/ase/symmetry.py b/qmctorch/ase/symmetry.py
new file mode 100644
index 00000000..b32aa3b3
--- /dev/null
+++ b/qmctorch/ase/symmetry.py
@@ -0,0 +1,153 @@
+
+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 = "C1"):
+        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
+
+    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
+        raise NotImplementedError("Dinfh symmetry not implemented yet")
\ No newline at end of file
diff --git a/qmctorch/sampler/metropolis.py b/qmctorch/sampler/metropolis.py
index be30cbdb..9f25994f 100644
--- a/qmctorch/sampler/metropolis.py
+++ b/qmctorch/sampler/metropolis.py
@@ -20,6 +20,7 @@ def __init__(  # pylint: disable=dangerous-default-value
         init: Dict = {"min": -5, "max": 5},
         move: Dict = {"type": "all-elec", "proba": "normal"},
         logspace: bool = False,
+        symmetry = None,
         cuda: bool = False,
     ):
         """Metropolis Hasting generator
@@ -59,6 +60,10 @@ def __init__(  # pylint: disable=dangerous-default-value
         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):
         """log data about the sampler."""
@@ -108,7 +113,10 @@ def __call__(
             if self.ntherm < 0:
                 self.ntherm = self.nstep + self.ntherm
 
+            # init the walkers
             self.walkers.initialize(pos=pos)
+
+
             if self.logspace:
                 fx = self.log_func(pdf)(self.walkers.pos)
             else:
@@ -126,6 +134,7 @@ def __call__(
 
             for istep in rng:
                 for id_elec in self.fixed_id_elec_list:
+                    
                     # new positions
                     Xn = self.move(pdf, id_elec)
 
@@ -167,7 +176,7 @@ def __call__(
                 )
                 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):
         """Configure the electron moves
diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 2f5842e8..297e7660 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -83,6 +83,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.basis_name = basis
         self.save_scf_file = save_scf_file
         self.scf_level = scf
+        self.symmetry = None
 
         if rank == 0:
             log.info("")
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index a6944ab4..fd870b42 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -77,7 +77,7 @@ def configure(  # pylint: disable=too-many-arguments
             self.grad_method = grad
             self.evaluate_gradient = {
                 "auto": self.evaluate_grad_auto,
-                "manual": self.evaluate_grad_manual_3,
+                "manual": self.evaluate_grad_manual,
             }[grad]
 
         # resampling of the wave function
@@ -395,6 +395,8 @@ def evaluate_grad_manual(self, lpos):
             # compute the gradients
             psi.backward(weight)
 
+            print(self.wf.mo_scf.weight.grad)
+
             return torch.mean(eloc), eloc
 
         else:
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 7d925597..a3fe50ae 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -138,7 +138,7 @@ def init_molecular_orb(self, include_all_mo):
         # scf layer
         self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
         self.mo_scf.weight = self.get_mo_coeffs()
-        self.mo_scf.weight.requires_grad = False
+        self.mo_scf.weight.requires_grad = True
 
         # port the layer to cuda if needed
         if self.cuda:
@@ -284,7 +284,7 @@ def forward(self, x, ao=None):
         x = self.mo_scf(x)
 
         # mix the mos
-        x = self.mo(x)
+        # x = self.mo(x)
 
         # pool the mos
         x = self.pool(x)
@@ -624,7 +624,7 @@ 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())
+        return nn.Parameter(mo_coeff.transpose(0, 1), requires_grad=True)
 
     def update_mo_coeffs(self):
         """Update the Mo coefficient during a GO run."""

From 228e7f3fa1472da36721a7971d431ec94c2f3c3e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 12 Mar 2025 14:44:49 +0100
Subject: [PATCH 267/286] new mo layer

---
 docs/example/ase/h2.py                        |  33 ++++++----
 docs/example/ase/tmp_79_iqdx                  | Bin 10528 -> 0 bytes
 qmctorch/ase/ase.py                           |   3 +-
 .../orbitals/molecular_orbitals.py            |  62 ++++++++++++++++++
 qmctorch/wavefunction/slater_jastrow.py       |  52 +++++----------
 5 files changed, 101 insertions(+), 49 deletions(-)
 delete mode 100644 docs/example/ase/tmp_79_iqdx
 create mode 100644 qmctorch/wavefunction/orbitals/molecular_orbitals.py

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index ab6b2c5f..0fbd4f75 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -23,6 +23,7 @@
 # WF options
 # h2.calc.wf_options.configs = 'ground_state'
 h2.calc.wf_options.configs = 'single_double(2,4)'
+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}
@@ -50,22 +51,30 @@
 # Optimize the wave function
 h2.calc.initialize()
 
-print(h2.calc.wf.mo_scf.weight.data)
-print(h2.calc.wf.ao.bas_exp.data)
-mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
-# compute forces
-h2.get_forces()
-# h2.get_potential_energy()
 
+# wf = h2.calc.wf 
+# pos = torch.rand(5,6)
+# ao = wf.ao(pos)
 
-pos = torch.rand(2,6)
-sym_pos = h2.calc.sampler.symmetry(pos)
-h2.calc.wf.fc.weight.data = torch.rand(1, 16)
-print(h2.calc.wf.local_energy(pos))
-print(h2.calc.wf.local_energy(sym_pos))
+# print(wf.mo_scf(ao))
+# print(wf.mo(ao))
 
+# print(h2.calc.wf.mo_scf.weight.data)
+# print(h2.calc.wf.ao.bas_exp.data)
+# mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
+# # compute forces
+# h2.get_forces()
+h2.get_potential_energy()
 
-print(mo_init - h2.calc.wf.mo_scf.weight.data)
+
+# pos = torch.rand(2,6)
+# sym_pos = h2.calc.sampler.symmetry(pos)
+# h2.calc.wf.fc.weight.data = torch.rand(1, 16)
+# print(h2.calc.wf.local_energy(pos))
+# print(h2.calc.wf.local_energy(sym_pos))
+
+
+# print(mo_init - h2.calc.wf.mo_scf.weight.data)
 
 # use torch optim for the optimization
 # dyn = TorchOptimizer(h2, 
diff --git a/docs/example/ase/tmp_79_iqdx b/docs/example/ase/tmp_79_iqdx
deleted file mode 100644
index 44d5155ede99d06accd885da626f430e1e1488f3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10528
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

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index e773ace3..74db91f5 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -63,6 +63,7 @@ def __init__(self,
         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(
@@ -201,6 +202,7 @@ def set_wf(self):
                                 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)
@@ -240,7 +242,6 @@ def set_default_optimizer(self):
         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.mo_scf.parameters(), 'lr': 1E-2},
                 {'params': self.wf.fc.parameters(), 'lr': 1E-2}]
         self.optimizer = optim.Adam(lr_dict, lr=1E-2)
 
diff --git a/qmctorch/wavefunction/orbitals/molecular_orbitals.py b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
new file mode 100644
index 00000000..9c389926
--- /dev/null
+++ b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
@@ -0,0 +1,62 @@
+import torch
+from torch import nn
+from torch.nn.utils.parametrizations import orthogonal 
+
+class MolecularOrbitals(nn.Module):
+    def __init__(self, mol, 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(self.nmo_opt, self.nmo_opt, 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.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/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index a3fe50ae..7754c921 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -16,6 +16,7 @@
 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
@@ -33,6 +34,7 @@ def __init__(
         kinetic="jacobi",
         cuda=False,
         include_all_mo=True,
+        mix_mo = False,
         orthogonalize_mo=False
     ):
         """Slater Jastrow wave function with electron-electron Jastrow factor
@@ -92,10 +94,7 @@ def __init__(
         self.init_atomic_orb(backflow)
 
         # init mo layer
-        self.init_molecular_orb(include_all_mo)
-
-        # init the mo mixer layer
-        self.init_mo_mixer(orthogonalize_mo)
+        self.init_molecular_orb(include_all_mo, mix_mo, orthogonalize_mo)
 
         # initialize the slater det calculator
         self.init_slater_det_calculator()
@@ -110,7 +109,7 @@ def __init__(
         self.init_kinetic(kinetic, backflow)
 
         # register the callable for hdf5 dump
-        register_extra_attributes(self, ["ao", "mo_scf", "mo", "jastrow", "pool", "fc"])
+        register_extra_attributes(self, ["ao", "mo", "jastrow", "pool", "fc"])
 
         self.log_data()
 
@@ -128,48 +127,33 @@ def init_atomic_orb(self, backflow):
         if self.cuda:
             self.ao = self.ao.to(self.device)
 
-    def init_molecular_orb(self, include_all_mo):
+    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
+        # # 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
 
         # scf layer
         self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
         self.mo_scf.weight = self.get_mo_coeffs()
-        self.mo_scf.weight.requires_grad = True
+        self.mo_scf.weight.requires_grad = False
 
         # port the layer to cuda if needed
         if self.cuda:
             self.mo_scf.to(self.device)
 
-    def init_mo_mixer(self, orthogonalize_mo):
-        """
-        Initialize the molecular orbital mixing layer.
-
-        Parameters
-        ----------
-        orthogonalize_mo : bool
-            whether to orthogonalize the mo mixer layer
-
-        """
-        self.orthogonalize_mo = orthogonalize_mo
-
-        # mo mixer layer
-        self.mo = nn.Linear(self.nmo_opt, self.nmo_opt, bias=False)
+        self.mo = MolecularOrbitals(self.mol, 
+                                    include_all_mo, 
+                                    self.highest_occ_mo, 
+                                    mix_mo,
+                                    orthogonalize_mo,
+                                    self.cuda)
 
-        # init the weight to idenity matrix
-        self.mo.weight = nn.Parameter(torch.eye(self.nmo_opt, self.nmo_opt))
-
-        # orthogonalize it
-        if self.orthogonalize_mo:
-            self.mo = orthogonal(self.mo)
-
-        # put on the card if needed
         if self.cuda:
             self.mo.to(self.device)
 
+
     def init_config(self, configs):
         """Initialize the electronic configurations desired in the wave function."""
 
@@ -281,10 +265,7 @@ def forward(self, x, ao=None):
             x = ao
 
         # molecular orbitals
-        x = self.mo_scf(x)
-
-        # mix the mos
-        # x = self.mo(x)
+        x = self.mo(x)
 
         # pool the mos
         x = self.pool(x)
@@ -298,8 +279,7 @@ def forward(self, x, ao=None):
 
     def ao2mo(self, ao):
         """transforms AO values in to MO values."""
-
-        return self.mo(self.mo_scf(ao))
+        return self.mo(ao)
 
     def pos2mo(self, x, derivative=0, sum_grad=True):
         """Compute the MO vals from the pos

From ec68656174de5a4ff388a14118451de21e16cf3d Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 13 Mar 2025 15:03:40 +0100
Subject: [PATCH 268/286] added selected configs

---
 docs/example/ase/h2.py                                | 11 ++++++++---
 .../wavefunction/pooling/orbital_configurations.py    |  7 ++++++-
 qmctorch/wavefunction/pooling/slater_pooling.py       |  5 +++++
 qmctorch/wavefunction/slater_jastrow.py               |  5 ++++-
 4 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 0fbd4f75..7fa99314 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -11,6 +11,9 @@
 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)])
 
@@ -22,7 +25,8 @@
 
 # WF options
 # h2.calc.wf_options.configs = 'ground_state'
-h2.calc.wf_options.configs = 'single_double(2,4)'
+# 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
@@ -38,7 +42,7 @@
 
 # solver options
 h2.calc.solver_options.freeze = []
-h2.calc.solver_options.niter = 0
+h2.calc.solver_options.niter = 10
 h2.calc.solver_options.tqdm = True
 h2.calc.solver_options.grad = 'manual'
 
@@ -64,7 +68,8 @@
 # mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
 # # compute forces
 # h2.get_forces()
-h2.get_potential_energy()
+# h2.get_potential_energy()
+
 
 
 # pos = torch.rand(2,6)
diff --git a/qmctorch/wavefunction/pooling/orbital_configurations.py b/qmctorch/wavefunction/pooling/orbital_configurations.py
index 8061b290..2268fb71 100644
--- a/qmctorch/wavefunction/pooling/orbital_configurations.py
+++ b/qmctorch/wavefunction/pooling/orbital_configurations.py
@@ -24,7 +24,11 @@ def get_configs(self, configs):
         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":
@@ -54,6 +58,7 @@ def get_configs(self, configs):
             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):
diff --git a/qmctorch/wavefunction/pooling/slater_pooling.py b/qmctorch/wavefunction/pooling/slater_pooling.py
index dd48ae3c..8ef0efdc 100644
--- a/qmctorch/wavefunction/pooling/slater_pooling.py
+++ b/qmctorch/wavefunction/pooling/slater_pooling.py
@@ -64,6 +64,8 @@ def forward(self, input):
         """
         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)
@@ -267,6 +269,9 @@ def operator(self, mo, bop, op=op.add, op_squared=False, inv_mo=None):
         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)
 
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 7754c921..bf8e2ed3 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -159,7 +159,10 @@ def init_config(self, configs):
 
         # define the SD we want
         self.orb_confs = OrbitalConfigurations(self.mol)
-        self.configs_method = configs
+        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

From dabe124a872d8b552cd09135baeeaa66f1b72832 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Thu, 13 Mar 2025 16:08:57 +0100
Subject: [PATCH 269/286] add mo_scf tpo gpu

---
 docs/example/ase/h2.py                               | 4 ++--
 qmctorch/solver/solver.py                            | 2 --
 qmctorch/wavefunction/orbitals/molecular_orbitals.py | 2 +-
 qmctorch/wavefunction/slater_jastrow.py              | 2 +-
 4 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 7fa99314..2de64d25 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -25,8 +25,8 @@
 
 # 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.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
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index fd870b42..31c5583a 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -395,8 +395,6 @@ def evaluate_grad_manual(self, lpos):
             # compute the gradients
             psi.backward(weight)
 
-            print(self.wf.mo_scf.weight.grad)
-
             return torch.mean(eloc), eloc
 
         else:
diff --git a/qmctorch/wavefunction/orbitals/molecular_orbitals.py b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
index 9c389926..fc91d647 100644
--- a/qmctorch/wavefunction/orbitals/molecular_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
@@ -31,7 +31,7 @@ def __init__(self, mol, include_all_mo: bool, highest_occ_mo: int, mix_mo: bool,
                 self.mo_mixer = orthogonal(self.mo_mixer)
 
         if self.cuda:
-            self.mo_scf.to(self.device)
+            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)
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index bf8e2ed3..0f033869 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -152,7 +152,7 @@ def init_molecular_orb(self, include_all_mo, mix_mo, orthogonalize_mo):
 
         if self.cuda:
             self.mo.to(self.device)
-
+            
 
     def init_config(self, configs):
         """Initialize the electronic configurations desired in the wave function."""

From c6bd7d089a00830bfaa785702b4acb21e94614a3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 14 Mar 2025 10:54:40 +0100
Subject: [PATCH 270/286] refator

---
 docs/example/ase/h2.py                        | 19 +++++++++++++++++--
 qmctorch/ase/ase.py                           |  2 +-
 qmctorch/{ase => sampler}/symmetry.py         |  2 +-
 .../orbitals/molecular_orbitals.py            | 10 ++++++++--
 qmctorch/wavefunction/slater_jastrow.py       | 16 ----------------
 5 files changed, 27 insertions(+), 22 deletions(-)
 rename qmctorch/{ase => sampler}/symmetry.py (99%)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 2de64d25..623ec28e 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,6 +1,6 @@
 from qmctorch.ase import QMCTorch     
 from qmctorch.ase.optimizer import TorchOptimizer
-from qmctorch.ase.symmetry import Cinfv
+from qmctorch.sampler.symmetry import Cinfv
 from ase import Atoms 
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
@@ -38,7 +38,7 @@
 h2.calc.sampler_options.step_size = 0.5
 h2.calc.sampler_options.ntherm = 400
 h2.calc.sampler_options.ndecor = 10
-h2.calc.sampler_options.symmetry = Cinfv(axis='z')
+h2.calc.sampler_options.symmetry = None
 
 # solver options
 h2.calc.solver_options.freeze = []
@@ -55,6 +55,21 @@
 # Optimize the wave function
 h2.calc.initialize()
 
+# single point
+obs = h2.calc.solver.single_point()
+pos = obs.pos 
+
+h2.calc.solver.evaluate_grad_manual(pos)
+print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+h2.calc.solver.wf.zero_grad() 
+
+
+symm_pos = Cinfv(axis='z')(pos)
+h2.calc.solver.evaluate_grad_manual(symm_pos)
+print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+h2.calc.solver.wf.zero_grad()
 
 # wf = h2.calc.wf 
 # pos = torch.rand(5,6)
diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 74db91f5..23477012 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -5,7 +5,7 @@
 from torch import optim
 from types import SimpleNamespace
 
-from .symmetry import BaseSymmetry
+from ..sampler.symmetry import BaseSymmetry
 from ..utils import set_torch_double_precision
 from ..utils.constants import ANGS2BOHR
 from ..scf.molecule import Molecule as SCF
diff --git a/qmctorch/ase/symmetry.py b/qmctorch/sampler/symmetry.py
similarity index 99%
rename from qmctorch/ase/symmetry.py
rename to qmctorch/sampler/symmetry.py
index b32aa3b3..1b310f28 100644
--- a/qmctorch/ase/symmetry.py
+++ b/qmctorch/sampler/symmetry.py
@@ -33,7 +33,7 @@ def planar_symmetry(pos: torch.tensor, plane: str, nelec: int, ndim: int, inplac
     return out
 
 class BaseSymmetry(ABC):
-    def __init__(self, label: str = "C1"):
+    def __init__(self, label: str):
         self.label = label
         self.nelec = None
         self.ndim = 3
diff --git a/qmctorch/wavefunction/orbitals/molecular_orbitals.py b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
index fc91d647..7262c675 100644
--- a/qmctorch/wavefunction/orbitals/molecular_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
@@ -1,9 +1,15 @@
 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, include_all_mo: bool, highest_occ_mo: int, mix_mo: bool, orthogonalize_mo: bool, cuda: bool):
+    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()
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 0f033869..28c954e2 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -134,15 +134,6 @@ def init_molecular_orb(self, include_all_mo, mix_mo, orthogonalize_mo):
         self.include_all_mo = include_all_mo
         self.nmo_opt = self.mol.basis.nmo if include_all_mo else self.highest_occ_mo
 
-        # scf layer
-        self.mo_scf = nn.Linear(self.mol.basis.nao, self.nmo_opt, bias=False)
-        self.mo_scf.weight = self.get_mo_coeffs()
-        self.mo_scf.weight.requires_grad = False
-
-        # port the layer to cuda if needed
-        if self.cuda:
-            self.mo_scf.to(self.device)
-
         self.mo = MolecularOrbitals(self.mol, 
                                     include_all_mo, 
                                     self.highest_occ_mo, 
@@ -602,13 +593,6 @@ def log_data(self):
         if self.cuda:
             log.info("  GPU                 : {0}", torch.cuda.get_device_name(0))
 
-    def get_mo_coeffs(self):
-        """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 nn.Parameter(mo_coeff.transpose(0, 1), requires_grad=True)
-
     def update_mo_coeffs(self):
         """Update the Mo coefficient during a GO run."""
         self.mol.atom_coords = self.ao.atom_coords.detach().numpy().tolist()

From c8504de0350c73b371eb49499a8713cda7d587e4 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 14 Mar 2025 11:30:51 +0100
Subject: [PATCH 271/286] added dinfh ymm

---
 docs/example/ase/h2.py       | 12 ++++++------
 qmctorch/sampler/symmetry.py | 13 ++++++++++++-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index 623ec28e..6748673b 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -1,6 +1,6 @@
 from qmctorch.ase import QMCTorch     
 from qmctorch.ase.optimizer import TorchOptimizer
-from qmctorch.sampler.symmetry import Cinfv
+from qmctorch.sampler.symmetry import Cinfv, Dinfh
 from ase import Atoms 
 from ase.optimize import GoodOldQuasiNewton, FIRE
 from ase.io import write
@@ -60,15 +60,15 @@
 pos = obs.pos 
 
 h2.calc.solver.evaluate_grad_manual(pos)
-print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# print(h2.calc.solver.wf.fc.weight.grad)
+print(h2.calc.solver.wf.ao.bas_exp.grad)
 h2.calc.solver.wf.zero_grad() 
 
 
-symm_pos = Cinfv(axis='z')(pos)
+symm_pos = Dinfh(axis='z')(pos)
 h2.calc.solver.evaluate_grad_manual(symm_pos)
-print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# print(h2.calc.solver.wf.fc.weight.grad)
+print(h2.calc.solver.wf.ao.bas_exp.grad)
 h2.calc.solver.wf.zero_grad()
 
 # wf = h2.calc.wf 
diff --git a/qmctorch/sampler/symmetry.py b/qmctorch/sampler/symmetry.py
index 1b310f28..b69ee6c1 100644
--- a/qmctorch/sampler/symmetry.py
+++ b/qmctorch/sampler/symmetry.py
@@ -133,6 +133,11 @@ def __init__(self, axis: str):
         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:
         """
@@ -150,4 +155,10 @@ def __call__(self, pos: torch.tensor) -> torch.tensor:
         """
         if self.nelec is None:
             self.nelec = pos.shape[1] // self.ndim
-        raise NotImplementedError("Dinfh symmetry not implemented yet")
\ No newline at end of file
+        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

From e12ad97a38c1991b62e03cb80ff61d76dd9d2e77 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Fri, 14 Mar 2025 15:15:09 +0100
Subject: [PATCH 272/286] reize mo_modifier

---
 docs/example/ase/HLi.xyz                      |   4 +
 docs/example/ase/h2.py                        |  32 ++---
 docs/example/ase/lih.py                       | 109 ++++++++++++++++++
 .../orbitals/molecular_orbitals.py            |   2 +-
 4 files changed, 131 insertions(+), 16 deletions(-)
 create mode 100644 docs/example/ase/HLi.xyz
 create mode 100644 docs/example/ase/lih.py

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
index 6748673b..ea4cdf1b 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -33,16 +33,16 @@
 h2.calc.wf_options.jastrow.kernel_kwargs = {'w':1.0}
 
 # sampler options
-h2.calc.sampler_options.nwalkers = 100
+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 = 400
+h2.calc.sampler_options.ntherm = -1
 h2.calc.sampler_options.ndecor = 10
-h2.calc.sampler_options.symmetry = None
+h2.calc.sampler_options.symmetry = Dinfh(axis='z')
 
 # solver options
 h2.calc.solver_options.freeze = []
-h2.calc.solver_options.niter = 10
+h2.calc.solver_options.niter = 50
 h2.calc.solver_options.tqdm = True
 h2.calc.solver_options.grad = 'manual'
 
@@ -55,21 +55,23 @@
 # Optimize the wave function
 h2.calc.initialize()
 
+h2.get_potential_energy()
+
 # single point
-obs = h2.calc.solver.single_point()
-pos = obs.pos 
+# obs = h2.calc.solver.single_point()
+# pos = obs.pos 
 
-h2.calc.solver.evaluate_grad_manual(pos)
-# print(h2.calc.solver.wf.fc.weight.grad)
-print(h2.calc.solver.wf.ao.bas_exp.grad)
-h2.calc.solver.wf.zero_grad() 
+# h2.calc.solver.evaluate_grad_manual(pos)
+# # print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# h2.calc.solver.wf.zero_grad() 
 
 
-symm_pos = Dinfh(axis='z')(pos)
-h2.calc.solver.evaluate_grad_manual(symm_pos)
-# print(h2.calc.solver.wf.fc.weight.grad)
-print(h2.calc.solver.wf.ao.bas_exp.grad)
-h2.calc.solver.wf.zero_grad()
+# symm_pos = Dinfh(axis='z')(pos)
+# h2.calc.solver.evaluate_grad_manual(symm_pos)
+# # print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# h2.calc.solver.wf.zero_grad()
 
 # wf = h2.calc.wf 
 # pos = torch.rand(5,6)
diff --git a/docs/example/ase/lih.py b/docs/example/ase/lih.py
new file mode 100644
index 00000000..cd0f17b9
--- /dev/null
+++ b/docs/example/ase/lih.py
@@ -0,0 +1,109 @@
+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()
+
+# single point
+# obs = h2.calc.solver.single_point()
+# pos = obs.pos 
+
+# h2.calc.solver.evaluate_grad_manual(pos)
+# # print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# h2.calc.solver.wf.zero_grad() 
+
+
+# symm_pos = Dinfh(axis='z')(pos)
+# h2.calc.solver.evaluate_grad_manual(symm_pos)
+# # print(h2.calc.solver.wf.fc.weight.grad)
+# print(h2.calc.solver.wf.ao.bas_exp.grad)
+# h2.calc.solver.wf.zero_grad()
+
+# wf = h2.calc.wf 
+# pos = torch.rand(5,6)
+# ao = wf.ao(pos)
+
+# print(wf.mo_scf(ao))
+# print(wf.mo(ao))
+
+# print(h2.calc.wf.mo_scf.weight.data)
+# print(h2.calc.wf.ao.bas_exp.data)
+# mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
+# # compute forces
+# h2.get_forces()
+# h2.get_potential_energy()
+
+
+
+# pos = torch.rand(2,6)
+# sym_pos = h2.calc.sampler.symmetry(pos)
+# h2.calc.wf.fc.weight.data = torch.rand(1, 16)
+# print(h2.calc.wf.local_energy(pos))
+# print(h2.calc.wf.local_energy(sym_pos))
+
+
+# print(mo_init - h2.calc.wf.mo_scf.weight.data)
+
+# use torch optim for the optimization
+# dyn = TorchOptimizer(h2, 
+#                      trajectory='traj.xyz', 
+#                      nepoch_wf_init=50, 
+#                      nepoch_wf_update=15, 
+#                      tqdm=True)
+# dyn = FIRE(h2, trajectory='traj.xyz')
+# dyn.run(fmax=0.005, steps=5)
+# write('final.xyz',h2)
diff --git a/qmctorch/wavefunction/orbitals/molecular_orbitals.py b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
index 7262c675..eb758041 100644
--- a/qmctorch/wavefunction/orbitals/molecular_orbitals.py
+++ b/qmctorch/wavefunction/orbitals/molecular_orbitals.py
@@ -28,7 +28,7 @@ def __init__(self,
         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(self.nmo_opt, self.nmo_opt, requires_grad=True)).type(dtype)
+        self.mo_modifier = nn.Parameter(torch.ones_like(self.mo_scf, requires_grad=True)).type(dtype)
 
         self.mo_mixed = None
         if self.mix_mo:

From 05038a13ce11a3c2eabc798d821e0baa1e958bc3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 24 Mar 2025 10:20:15 +0100
Subject: [PATCH 273/286] remove symmetry and ortho

---
 qmctorch/scf/molecule.py                |  1 -
 qmctorch/solver/solver.py               |  9 ++-------
 qmctorch/solver/solver_mpi.py           |  2 +-
 qmctorch/utils/__init__.py              |  2 --
 qmctorch/utils/torch_utils.py           | 17 -----------------
 qmctorch/wavefunction/slater_jastrow.py |  1 +
 6 files changed, 4 insertions(+), 28 deletions(-)

diff --git a/qmctorch/scf/molecule.py b/qmctorch/scf/molecule.py
index 297e7660..2f5842e8 100644
--- a/qmctorch/scf/molecule.py
+++ b/qmctorch/scf/molecule.py
@@ -83,7 +83,6 @@ def __init__(  # pylint: disable=too-many-arguments
         self.basis_name = basis
         self.save_scf_file = save_scf_file
         self.scf_level = scf
-        self.symmetry = None
 
         if rank == 0:
             log.info("")
diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 31c5583a..9973a0e5 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -2,7 +2,7 @@
 from time import time
 from tqdm import tqdm
 import torch
-from qmctorch.utils import Loss, OrthoReg, add_group_attr, dump_to_hdf5, DataLoader
+from qmctorch.utils import Loss, add_group_attr, dump_to_hdf5, DataLoader
 
 from .. import log
 from .solver_base import SolverBase
@@ -92,8 +92,7 @@ def configure(  # pylint: disable=too-many-arguments
         # orthogonalization penalty for the MO coeffs
         self.ortho_mo = ortho_mo
         if self.ortho_mo is True:
-            log.warning("Orthogonalization of the MO coeffs is better done in the wave function")
-            self.ortho_loss = OrthoReg()
+            log.warning("Orthogonalization of the MO coeffs via loss penalty is deprecated")
 
     def set_params_requires_grad(self, wf_params=True, geo_params=False):
         """Configure parameters for wf opt."""
@@ -334,10 +333,6 @@ 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
         loss.backward()
 
diff --git a/qmctorch/solver/solver_mpi.py b/qmctorch/solver/solver_mpi.py
index 54e6a118..a7e4e4d4 100644
--- a/qmctorch/solver/solver_mpi.py
+++ b/qmctorch/solver/solver_mpi.py
@@ -2,7 +2,7 @@
 from types import SimpleNamespace
 
 import torch
-from qmctorch.utils import DataLoader, Loss, OrthoReg, add_group_attr, dump_to_hdf5
+from qmctorch.utils import DataLoader, Loss, add_group_attr, dump_to_hdf5
 
 from .. import log
 from .solver import Solver
diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index a81cdea5..a29e8f12 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -22,7 +22,6 @@
     DataSet,
     DataLoader,
     Loss,
-    OrthoReg,
     fast_power,
     set_torch_double_precision,
     set_torch_single_precision,
@@ -35,7 +34,6 @@
     "set_torch_single_precision",
     "DataSet",
     "Loss",
-    "OrthoReg",
     "DataLoader",
     "add_group_attr",
     "dump_to_hdf5",
diff --git a/qmctorch/utils/torch_utils.py b/qmctorch/utils/torch_utils.py
index c488172c..a94dbdad 100644
--- a/qmctorch/utils/torch_utils.py
+++ b/qmctorch/utils/torch_utils.py
@@ -283,20 +283,3 @@ def get_sampling_weights(self, pos, deactivate_weight):
 
         else:
             return 1.0
-
-
-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]))
diff --git a/qmctorch/wavefunction/slater_jastrow.py b/qmctorch/wavefunction/slater_jastrow.py
index 28c954e2..12903d3d 100644
--- a/qmctorch/wavefunction/slater_jastrow.py
+++ b/qmctorch/wavefunction/slater_jastrow.py
@@ -712,3 +712,4 @@ def sto(x, norm, alpha):
             cuda=self.cuda,
             include_all_mo=self.include_all_mo,
         )
+

From ae451f2e1eefd94f64f6fa8e692d30a91e484689 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 24 Mar 2025 10:38:50 +0100
Subject: [PATCH 274/286] added symmetry test

---
 tests/sampler/test_symmetry.py | 68 ++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 tests/sampler/test_symmetry.py

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

From 78accf9a0df89ef5f19a8d12a856f7aab94fab23 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 24 Mar 2025 10:47:12 +0100
Subject: [PATCH 275/286] fix mo_scf bug in orbital dep slaer jastrow wf

---
 qmctorch/wavefunction/slater_orbital_dependent_jastrow.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
index e1b5e2d4..68e99db7 100644
--- a/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
+++ b/qmctorch/wavefunction/slater_orbital_dependent_jastrow.py
@@ -137,9 +137,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
@@ -152,10 +149,10 @@ 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):
         """Compute the uncorrelated MOs from the positions."""

From 118320a801f6c4f27956dc43837968b9101d440e Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 24 Mar 2025 11:02:18 +0100
Subject: [PATCH 276/286] remove mo_scf from other files

---
 docs/example/ase/h2.py                        | 50 -------------------
 docs/example/ase/lih.py                       | 50 -------------------
 qmctorch/utils/interpolate.py                 |  4 +-
 tests/utils/test_interpolate.py               |  4 +-
 .../orbitals/test_mo_values_adf.py            |  2 +-
 5 files changed, 5 insertions(+), 105 deletions(-)

diff --git a/docs/example/ase/h2.py b/docs/example/ase/h2.py
index ea4cdf1b..b777a5bf 100644
--- a/docs/example/ase/h2.py
+++ b/docs/example/ase/h2.py
@@ -57,53 +57,3 @@
 
 h2.get_potential_energy()
 
-# single point
-# obs = h2.calc.solver.single_point()
-# pos = obs.pos 
-
-# h2.calc.solver.evaluate_grad_manual(pos)
-# # print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
-# h2.calc.solver.wf.zero_grad() 
-
-
-# symm_pos = Dinfh(axis='z')(pos)
-# h2.calc.solver.evaluate_grad_manual(symm_pos)
-# # print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
-# h2.calc.solver.wf.zero_grad()
-
-# wf = h2.calc.wf 
-# pos = torch.rand(5,6)
-# ao = wf.ao(pos)
-
-# print(wf.mo_scf(ao))
-# print(wf.mo(ao))
-
-# print(h2.calc.wf.mo_scf.weight.data)
-# print(h2.calc.wf.ao.bas_exp.data)
-# mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
-# # compute forces
-# h2.get_forces()
-# h2.get_potential_energy()
-
-
-
-# pos = torch.rand(2,6)
-# sym_pos = h2.calc.sampler.symmetry(pos)
-# h2.calc.wf.fc.weight.data = torch.rand(1, 16)
-# print(h2.calc.wf.local_energy(pos))
-# print(h2.calc.wf.local_energy(sym_pos))
-
-
-# print(mo_init - h2.calc.wf.mo_scf.weight.data)
-
-# use torch optim for the optimization
-# dyn = TorchOptimizer(h2, 
-#                      trajectory='traj.xyz', 
-#                      nepoch_wf_init=50, 
-#                      nepoch_wf_update=15, 
-#                      tqdm=True)
-# dyn = FIRE(h2, trajectory='traj.xyz')
-# dyn.run(fmax=0.005, steps=5)
-# write('final.xyz',h2)
diff --git a/docs/example/ase/lih.py b/docs/example/ase/lih.py
index cd0f17b9..4d6917bb 100644
--- a/docs/example/ase/lih.py
+++ b/docs/example/ase/lih.py
@@ -57,53 +57,3 @@
 
 h2.get_potential_energy()
 
-# single point
-# obs = h2.calc.solver.single_point()
-# pos = obs.pos 
-
-# h2.calc.solver.evaluate_grad_manual(pos)
-# # print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
-# h2.calc.solver.wf.zero_grad() 
-
-
-# symm_pos = Dinfh(axis='z')(pos)
-# h2.calc.solver.evaluate_grad_manual(symm_pos)
-# # print(h2.calc.solver.wf.fc.weight.grad)
-# print(h2.calc.solver.wf.ao.bas_exp.grad)
-# h2.calc.solver.wf.zero_grad()
-
-# wf = h2.calc.wf 
-# pos = torch.rand(5,6)
-# ao = wf.ao(pos)
-
-# print(wf.mo_scf(ao))
-# print(wf.mo(ao))
-
-# print(h2.calc.wf.mo_scf.weight.data)
-# print(h2.calc.wf.ao.bas_exp.data)
-# mo_init = torch.clone(h2.calc.wf.mo_scf.weight.data)
-# # compute forces
-# h2.get_forces()
-# h2.get_potential_energy()
-
-
-
-# pos = torch.rand(2,6)
-# sym_pos = h2.calc.sampler.symmetry(pos)
-# h2.calc.wf.fc.weight.data = torch.rand(1, 16)
-# print(h2.calc.wf.local_energy(pos))
-# print(h2.calc.wf.local_energy(sym_pos))
-
-
-# print(mo_init - h2.calc.wf.mo_scf.weight.data)
-
-# use torch optim for the optimization
-# dyn = TorchOptimizer(h2, 
-#                      trajectory='traj.xyz', 
-#                      nepoch_wf_init=50, 
-#                      nepoch_wf_update=15, 
-#                      tqdm=True)
-# dyn = FIRE(h2, trajectory='traj.xyz')
-# dyn.run(fmax=0.005, steps=5)
-# write('final.xyz',h2)
diff --git a/qmctorch/utils/interpolate.py b/qmctorch/utils/interpolate.py
index c0b0c2ab..31d4b0c1 100644
--- a/qmctorch/utils/interpolate.py
+++ b/qmctorch/utils/interpolate.py
@@ -60,7 +60,7 @@ def interpolate_mo_irreg_grid(self, pos, n, orb):
             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)
+                mo = self.wf.mo(ao).squeeze(1)
                 return mo[:, : self.mo_max_index].detach()
 
             self.interp_mo_func = interpolator_irreg_grid(func, grid_pts)
@@ -92,7 +92,7 @@ def interpolate_mo_reg_grid(self, pos, res, blength, orb):
             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)
+                mo = self.wf.mo(ao).squeeze(1)
                 return mo[:, : self.mo_max_index]
 
             self.interp_mo_func = interpolator_reg_grid(func, x, y, z)
diff --git a/tests/utils/test_interpolate.py b/tests/utils/test_interpolate.py
index b8229b52..30cf30f6 100644
--- a/tests/utils/test_interpolate.py
+++ b/tests/utils/test_interpolate.py
@@ -40,14 +40,14 @@ def test_ao(self):
     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)))
+        ref = self.wf.mo(self.wf.ao(self.pos))
         delta = (inter - ref).abs().mean()
         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)))
+        ref = self.wf.mo(self.wf.ao(self.pos))
         delta = (inter - ref).abs().mean()
         assert delta < 0.1
 
diff --git a/tests/wavefunction/orbitals/test_mo_values_adf.py b/tests/wavefunction/orbitals/test_mo_values_adf.py
index 73841d09..8bd5761e 100644
--- a/tests/wavefunction/orbitals/test_mo_values_adf.py
+++ b/tests/wavefunction/orbitals/test_mo_values_adf.py
@@ -72,7 +72,7 @@ def setUp(self):
         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"

From b3c2c0b530c4f5ff6dc891da897501bee6b84fa3 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Wed, 26 Mar 2025 17:07:45 +0100
Subject: [PATCH 277/286] fix Loss  import bug

---
 qmctorch/utils/__init__.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/qmctorch/utils/__init__.py b/qmctorch/utils/__init__.py
index a29e8f12..0c2e97c2 100644
--- a/qmctorch/utils/__init__.py
+++ b/qmctorch/utils/__init__.py
@@ -21,7 +21,6 @@
 from .torch_utils import (
     DataSet,
     DataLoader,
-    Loss,
     fast_power,
     set_torch_double_precision,
     set_torch_single_precision,
@@ -33,7 +32,6 @@
     "set_torch_double_precision",
     "set_torch_single_precision",
     "DataSet",
-    "Loss",
     "DataLoader",
     "add_group_attr",
     "dump_to_hdf5",

From 56a8e2035d6ad948f3c927752ed0d869c212de32 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 31 Mar 2025 17:15:59 +0200
Subject: [PATCH 278/286] added force calculator

---
 qmctorch/solver/solver.py | 69 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 9973a0e5..0418f4bf 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -505,6 +505,75 @@ def evaluate_grad_manual_3(self, lpos):
         else:
             raise ValueError("Manual gradient only for energy minimization")
 
+    def compute_numerical_forces(self, lpos: torch.tensor, eps: float = 1E-3) -> torch.tensor:
+        """Compute the numerical forces
+
+        Args:
+            lpos (torch.tensor): sampling points
+            eps (float, optional): the finite difference step. Defaults to 1E-3.
+
+        Returns:
+            torch.tensor: the numerical forces
+        """
+        
+        def displace_atom(idx_atom: int , idx_dir: int, eps: float, pos: torch.tensor) -> torch.tensor: 
+            """Displace an atom in a given direction
+
+            Args:
+                idx_atom (int): index of the atom
+                idx_dir (int): index of the direction
+                eps (float): the finite difference step
+                pos (torch.tensor): positions of the atoms
+
+            Returns:
+                torch.tensor: the new positions of the atoms
+            """
+            new_pos = pos.clone()
+            new_pos[idx_atom, idx_dir] += eps
+            return new_pos    
+        
+        original_atom_coords = self.wf.ao.atom_coords.clone()
+        original_bas_coords = self.wf.ao.bas_coords.clone()
+
+        forces = torch.zeros((self.wf.natom, 3))
+        for i in range(self.wf.natom):
+            for j in range(3):
+                self.wf.ao.atom_coords.data = displace_atom(i, j, eps, original_atom_coords)
+                self.wf.ao.bas_coords.data = self.wf.ao.atom_coords.repeat_interleave(self.wf.ao.nshells, dim=0)
+                loss_p, _ = self.loss(lpos)
+
+                self.wf.ao.atom_coords.data = displace_atom(i, j, -eps, original_atom_coords)
+                self.wf.ao.bas_coords.data = self.wf.ao.atom_coords.repeat_interleave(self.wf.ao.nshells, dim=0)
+                loss_m, _ = self.loss(lpos)
+
+                forces [i, j] = (loss_p - loss_m) / (2.0 * eps)
+
+        self.wf.ao.atom_coords.data = original_atom_coords
+        self.wf.ao.bas_coords.data = original_bas_coords
+
+        return forces
+                
+    def compute_autograd_forces(self, lpos: torch.tensor) -> torch.tensor:
+        """Compute the forces using automatic differentation
+
+        Args:
+            lpos (torch.tensor): sampling points
+
+        Returns:
+            torch.tensor: the numerical forces
+        """
+        original_requires_grad = self.wf.ao.atom_coords.requires_grad
+
+        if not original_requires_grad:
+            self.wf.ao.atom_coords.requires_grad = True
+
+        loss, _ = self.loss(lpos)
+        forces =  torch.autograd.grad(loss, self.wf.ao.atom_coords, retain_graph=True)[0]
+
+        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."""

From d98fc607d3c5dda83fd0e9df4552235598b5e13f Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 1 Apr 2025 09:11:53 +0200
Subject: [PATCH 279/286] added stable esimator

---
 qmctorch/solver/solver.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 0418f4bf..04b87c19 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -575,6 +575,34 @@ def compute_autograd_forces(self, lpos: torch.tensor) -> torch.tensor:
 
         return forces
 
+    def compute_forces(self, lpos: torch.tensor) -> torch.tensor:
+        """
+        Compute the forces using automatic differentiation.
+
+        Args:
+            lpos (torch.tensor): sampling points
+
+        Returns:
+            torch.tensor: the numerical forces
+        """
+        original_requires_grad = self.wf.ao.atom_coords.requires_grad
+        batch_size = lpos.shape[0]
+        if not original_requires_grad:
+            self.wf.ao.atom_coords.requires_grad = True
+
+        local_energy = self.wf.local_energy(lpos)
+        grad_eloc =  torch.autograd.grad(local_energy, self.wf.ao.atom_coords, grad_outputs=torch.ones_like(local_energy))[0]
+
+        proba = torch.log(self.wf.pdf(lpos))
+        grad_output = (local_energy-local_energy.mean()).squeeze()
+        grad_proba = torch.autograd.grad(proba, self.wf.ao.atom_coords, grad_outputs=grad_output)[0]
+        
+        if not original_requires_grad:
+            self.wf.ao.atom_coords.requires_grad = False
+
+        return 1./batch_size * (grad_eloc + grad_proba)
+
+
     def log_data_opt(self, nepoch, task):
         """Log data for the optimization."""
         log.info("")

From 4b459979c3eaedef13d7cbbc1bd82f2b097b26fb Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 7 Apr 2025 09:17:10 +0200
Subject: [PATCH 280/286] force estimator

---
 qmctorch/solver/solver.py | 33 +++++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 04b87c19..f685ee5b 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -575,7 +575,7 @@ def compute_autograd_forces(self, lpos: torch.tensor) -> torch.tensor:
 
         return forces
 
-    def compute_forces(self, lpos: torch.tensor) -> torch.tensor:
+    def compute_forces(self, lpos: torch.tensor, batch_size: int = None) -> torch.tensor:
         """
         Compute the forces using automatic differentiation.
 
@@ -586,21 +586,38 @@ def compute_forces(self, lpos: torch.tensor) -> torch.tensor:
             torch.tensor: the numerical forces
         """
         original_requires_grad = self.wf.ao.atom_coords.requires_grad
-        batch_size = lpos.shape[0]
         if not original_requires_grad:
             self.wf.ao.atom_coords.requires_grad = True
 
-        local_energy = self.wf.local_energy(lpos)
-        grad_eloc =  torch.autograd.grad(local_energy, self.wf.ao.atom_coords, grad_outputs=torch.ones_like(local_energy))[0]
+        if batch_size is None:
+            batch_size = lpos.shape[0]
 
-        proba = torch.log(self.wf.pdf(lpos))
-        grad_output = (local_energy-local_energy.mean()).squeeze()
-        grad_proba = torch.autograd.grad(proba, self.wf.ao.atom_coords, grad_outputs=grad_output)[0]
+        forces = torch.zeros_like(self.wf.ao.atom_coords)
+
+        nbatch = lpos.shape[0]//batch_size
+        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]
+
+            local_energy = self.wf.local_energy(lpos_batch)
+            grad_eloc =  torch.autograd.grad(local_energy, self.wf.ao.atom_coords, grad_outputs=torch.ones_like(local_energy))[0]
+
+            wf_val = self.wf.pdf(lpos_batch)
+            proba = torch.log(wf_val)
+            grad_output = (local_energy-local_energy.mean()).squeeze()
+            grad_proba = torch.autograd.grad(proba, self.wf.ao.atom_coords, grad_outputs=grad_output)[0]
         
+            forces += 1./batch_size * (grad_eloc + grad_proba)
+
         if not original_requires_grad:
             self.wf.ao.atom_coords.requires_grad = False
 
-        return 1./batch_size * (grad_eloc + grad_proba)
+        return forces
 
 
     def log_data_opt(self, nepoch, task):

From fd02d6a34fc415eb2526b1cc1b851bcbe5716693 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 7 Apr 2025 11:14:14 +0200
Subject: [PATCH 281/286] clip forces

---
 qmctorch/solver/solver.py | 46 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 40 insertions(+), 6 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index f685ee5b..ee61e9fc 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -575,26 +575,56 @@ def compute_autograd_forces(self, lpos: torch.tensor) -> torch.tensor:
 
         return forces
 
-    def compute_forces(self, lpos: torch.tensor, batch_size: int = None) -> torch.tensor:
+    def compute_forces(self, lpos: torch.tensor, batch_size: int = None, clip: int = None) -> torch.tensor:
         """
-        Compute the forces using automatic differentiation.
+        Compute the forces using automatic differentation
 
         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, clip):
+            """
+            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)
 
-        nbatch = lpos.shape[0]//batch_size
         for ibatch in range(nbatch):
 
             # get the batch
@@ -604,14 +634,18 @@ def compute_forces(self, lpos: torch.tensor, batch_size: int = None) -> torch.te
                 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)
-            grad_eloc =  torch.autograd.grad(local_energy, self.wf.ao.atom_coords, grad_outputs=torch.ones_like(local_energy))[0]
+            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_output = (local_energy-local_energy.mean()).squeeze()
-            grad_proba = torch.autograd.grad(proba, self.wf.ao.atom_coords, grad_outputs=grad_output)[0]
+            grad_outputs = (local_energy-local_energy.mean()).squeeze() * clip_mask
+            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:

From c2f2c87fdfc3e962b369a5d818f9aa764a99b7b7 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Mon, 7 Apr 2025 11:24:53 +0200
Subject: [PATCH 282/286] fix clipping mask

---
 qmctorch/solver/solver.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index ee61e9fc..23f88ac0 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -642,7 +642,7 @@ def get_clipping_mask(values, clip):
             # 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()).squeeze() * clip_mask
+            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

From 61ffa9f21ac784e7f49c482db6e3c88a55b4d317 Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 8 Apr 2025 11:28:47 +0200
Subject: [PATCH 283/286] sampling trj on gpu

---
 qmctorch/solver/solver_base.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qmctorch/solver/solver_base.py b/qmctorch/solver/solver_base.py
index 09f7890b..ba86265b 100644
--- a/qmctorch/solver/solver_base.py
+++ b/qmctorch/solver/solver_base.py
@@ -432,9 +432,12 @@ def sampling_traj(self, pos=None, with_tqdm=True, hdf5_group="sampling_trajector
 
         ndim = pos.shape[-1]
         p = pos.view(-1, self.sampler.walkers.nwalkers, ndim)
+        
         el = []
         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)

From eb3598d636c68cc98ea25f7d487328e506dd180b Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 8 Apr 2025 14:15:58 +0200
Subject: [PATCH 284/286] clean up force calc

---
 qmctorch/solver/solver.py | 76 ++++-----------------------------------
 1 file changed, 6 insertions(+), 70 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 23f88ac0..1b0d7411 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -505,79 +505,15 @@ def evaluate_grad_manual_3(self, lpos):
         else:
             raise ValueError("Manual gradient only for energy minimization")
 
-    def compute_numerical_forces(self, lpos: torch.tensor, eps: float = 1E-3) -> torch.tensor:
-        """Compute the numerical forces
 
-        Args:
-            lpos (torch.tensor): sampling points
-            eps (float, optional): the finite difference step. Defaults to 1E-3.
-
-        Returns:
-            torch.tensor: the numerical forces
-        """
-        
-        def displace_atom(idx_atom: int , idx_dir: int, eps: float, pos: torch.tensor) -> torch.tensor: 
-            """Displace an atom in a given direction
-
-            Args:
-                idx_atom (int): index of the atom
-                idx_dir (int): index of the direction
-                eps (float): the finite difference step
-                pos (torch.tensor): positions of the atoms
-
-            Returns:
-                torch.tensor: the new positions of the atoms
-            """
-            new_pos = pos.clone()
-            new_pos[idx_atom, idx_dir] += eps
-            return new_pos    
-        
-        original_atom_coords = self.wf.ao.atom_coords.clone()
-        original_bas_coords = self.wf.ao.bas_coords.clone()
-
-        forces = torch.zeros((self.wf.natom, 3))
-        for i in range(self.wf.natom):
-            for j in range(3):
-                self.wf.ao.atom_coords.data = displace_atom(i, j, eps, original_atom_coords)
-                self.wf.ao.bas_coords.data = self.wf.ao.atom_coords.repeat_interleave(self.wf.ao.nshells, dim=0)
-                loss_p, _ = self.loss(lpos)
-
-                self.wf.ao.atom_coords.data = displace_atom(i, j, -eps, original_atom_coords)
-                self.wf.ao.bas_coords.data = self.wf.ao.atom_coords.repeat_interleave(self.wf.ao.nshells, dim=0)
-                loss_m, _ = self.loss(lpos)
-
-                forces [i, j] = (loss_p - loss_m) / (2.0 * eps)
-
-        self.wf.ao.atom_coords.data = original_atom_coords
-        self.wf.ao.bas_coords.data = original_bas_coords
-
-        return forces
-                
-    def compute_autograd_forces(self, lpos: torch.tensor) -> torch.tensor:
-        """Compute the forces using automatic differentation
-
-        Args:
-            lpos (torch.tensor): sampling points
-
-        Returns:
-            torch.tensor: the numerical forces
-        """
-        original_requires_grad = self.wf.ao.atom_coords.requires_grad
-
-        if not original_requires_grad:
-            self.wf.ao.atom_coords.requires_grad = True
-
-        loss, _ = self.loss(lpos)
-        forces =  torch.autograd.grad(loss, self.wf.ao.atom_coords, retain_graph=True)[0]
-
-        if not original_requires_grad:
-            self.wf.ao.atom_coords.requires_grad = False
+    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
 
-        return forces
+        ..math::
+            F = -\\langle \\nabla_\\alpha E_L(R) + (E_L(R) - E) \\nabla)\\alpha |\Psi(R)|^2 \\rangle
 
-    def compute_forces(self, lpos: torch.tensor, batch_size: int = None, clip: int = None) -> torch.tensor:
-        """
-        Compute the forces using automatic differentation
+        see e.g. https://arxiv.org/abs/2404.09755
 
         Args:
             lpos (torch.tensor): sampling points

From 15702b6cc9b0066be32de439d9a8ac3d112b8b2a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 8 Apr 2025 15:53:43 +0200
Subject: [PATCH 285/286] fix ase

---
 qmctorch/ase/ase.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/qmctorch/ase/ase.py b/qmctorch/ase/ase.py
index 23477012..df748b4e 100644
--- a/qmctorch/ase/ase.py
+++ b/qmctorch/ase/ase.py
@@ -14,6 +14,7 @@
 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):
@@ -105,6 +106,9 @@ def __init__(self,
         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:
         """
@@ -498,14 +502,11 @@ def _calculate_forces(self, atoms=None):
         observable = self.solver.single_point()
 
         # compute the forces 
-        # we use evaluate_grad_auto as evaluate_grad_manual is not
-        # valid for forces  
-        self.solver.set_params_requires_grad(wf_params=False, geo_params=True)
-        _, _ = self.solver.evaluate_grad_auto(observable.pos)
+        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'] = -self.solver.wf.ao.atom_coords.grad.cpu().numpy()
+        self.results['forces'] = forces
         self.solver.wf.zero_grad()
 
         self.has_forces = True

From 79bbfa1cf59ab569a4296c23914969e9652de11a Mon Sep 17 00:00:00 2001
From: Nico <nicolas.gm.renaud@gmail.com>
Date: Tue, 8 Apr 2025 16:23:14 +0200
Subject: [PATCH 286/286] typehints for force

---
 qmctorch/solver/solver.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmctorch/solver/solver.py b/qmctorch/solver/solver.py
index 7a8f6eb6..01ca123d 100644
--- a/qmctorch/solver/solver.py
+++ b/qmctorch/solver/solver.py
@@ -470,7 +470,7 @@ def evaluate_grad_manual_2(self, lpos: torch.Tensor) -> Tuple[torch.Tensor, torc
         else:
             raise ValueError("Manual gradient only for energy minimization")
 
-    def evaluate_grad_manual_3(self, lpos):
+    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 
@@ -546,7 +546,7 @@ def compute_forces(self, lpos: torch.tensor, batch_size: int = None, clip: int =
 
         """
 
-        def get_clipping_mask(values, clip):
+        def get_clipping_mask(values: torch.tensor, clip: int) -> torch.tensor:
             """
             Compute a mask to clip the values based on their zscore