Repository: ContactEngineering/Adhesion (language: python)

Issue:
BUG: System initializes its own engine
https://github.com/ContactEngineering/Adhesion/blob/85516ea1a4dd9a796ba89294694687c241f0f4b9/Adhesion/System/Systems.py#L77-L80

The biggest problem is that this engine is always serial ...
Explaining why my recent simulations needed a surprisingly high amount of memory when running in parallel.

I just need to replace with substrate.engine
Bug/local topography nb subdomain grid pts
Repairs bugs we had with handling Bounds in Free systems in MPI. 

This combination was never used and tested before.
Implement hessian of the preconditioned objective
This was started but there is still a bug. 

See lines commented out in commit 

52671bf2416248bbd46fa6d3c9294ff1a57fcddf


Discussion / hints:

Fix patch:
diff --git a/Adhesion/ChangeLog.md b/Adhesion/ChangeLog.md
index f5fb3a26..216fdada 100755
--- a/Adhesion/ChangeLog.md
+++ b/Adhesion/ChangeLog.md
@@ -1,15 +1,18 @@
 
-Change log for PyCo
-===================
+Change log for Adhesion
+=======================
 
-v0.90.0 (???)
--------------
-
-- Dropped support for python3.5 and scipy < 0.16.0
+v0.90.0 (210706)
+----------------
 
-- Refactored PyCo code into three separate Python modules:
+- ENH: preconditionned contact mechanics in fourier space
+- MAINT: Dropped support for python3.5 and scipy < 0.16.0
+- MAINT: Refactored PyCo code into three separate Python modules:
   SurfaceTopography, ContactMechanics and Adhesion
 
+Change log for PyCo (previous name of the package)
+==================================================
+
 v0.57.0 (15May20)
 -----------------
 
diff --git a/Adhesion/Interactions/Interactions.py b/Adhesion/Interactions/Interactions.py
index caeed174..0c715cdc 100644
--- a/Adhesion/Interactions/Interactions.py
+++ b/Adhesion/Interactions/Interactions.py
@@ -84,11 +84,11 @@ class SoftWall(Interaction):
     """base class for smooth contact mechanics"""
     def __init__(self, communicator=MPI.COMM_WORLD):
         self.communicator = communicator
-        self.pnp = Reduction(communicator)
+        self.reduction = Reduction(communicator)
 
     def __deepcopy__(self, memo):
         """
-        makes a deepcopy of all the attributes except self.pnp,
+        makes a deepcopy of all the attributes except self.reduction,
         where it stores the same reference
 
         Parameters
@@ -108,8 +108,8 @@ def __deepcopy__(self, memo):
         # exceptions
         # pnp is a module or a class impolenting computation methods,
         # it is not copied
-        result.pnp = self.pnp
-        keys.remove('pnp')
+        result.reduction = self.reduction
+        keys.remove('reduction')
         # same for communicator
         result.communicator = self.communicator
         keys.remove('communicator')
@@ -138,3 +138,31 @@ def evaluate(self, gap, potential=True, gradient=False):
             (default False) whether the gradient should be evaluated
         """
         raise NotImplementedError()
+
+    def plot(self):
+        import matplotlib.pyplot as plt
+        fig, (axpot, axf, axcurv) = plt.subplots(3, 1)
+        r = np.linspace(0.7 * self.r_min, 4 * self.r_min, 200)
+
+        v, dv, ddv = self.evaluate(r, True, True, True)
+
+        axpot.plot(r, v, )
+        axf.plot(r, dv, )
+        axcurv.plot(r, ddv, )
+
+        axpot.set_ylabel("Potential")
+        axf.set_ylabel("interaction stress")
+        axcurv.set_ylabel("curvature")
+
+        for a in (axpot, axf, axcurv):
+            a.grid()
+            a.axvline(self.r_min, label="r_min")
+            a.axvline(self.r_infl, label="r_infl")
+
+        axpot.axhline(self.v_min, c="k", label="v_min")
+        axf.axhline(self.max_tensile, c="k", label="maxtensile")
+
+        axcurv.set_xlabel("gap")
+        axpot.legend()
+
+        return fig, (axpot, axf, axcurv)
diff --git a/Adhesion/Interactions/Potentials.py b/Adhesion/Interactions/Potentials.py
index 3cb78ac4..d6cbd398 100644
--- a/Adhesion/Interactions/Potentials.py
+++ b/Adhesion/Interactions/Potentials.py
@@ -156,7 +156,7 @@ def pipeline(self):
 class DecoratedPotential(Potential):
     def __init__(self, parent_potential):
         self.parent_potential = parent_potential
-        self.pnp = parent_potential.pnp
+        self.reduction = parent_potential.reduction
         self.communicator = parent_potential.communicator
 
     def __getstate__(self):
diff --git a/Adhesion/Interactions/cutoffs.py b/Adhesion/Interactions/cutoffs.py
index 4938caa9..75bc9a5c 100644
--- a/Adhesion/Interactions/cutoffs.py
+++ b/Adhesion/Interactions/cutoffs.py
@@ -91,11 +91,11 @@ def fprime(r):
                 sol = scipy.optimize.root_scalar(
                     f, x0=self.r_ti,
                     fprime=fprime,
-                    options=dict(maxiter=50,
+                    options=dict(maxiter=4000,
                                  tol=htol / abs(fprime(self.r_ti)))
                     # this is the tolerance in |x - x0|
                     )
-                assert sol.converged, sol.message
+                assert sol.converged, sol.flag
                 self.r_ti = sol.root
             except FinfinityError as err:
                 # print("encountered infinity, make use of tweaky method")
@@ -119,7 +119,8 @@ def ftweaked(r):
                     left, self.r_ti,
                     xtol=1e-10 / abs(fprime(
                         self.r_ti)) * hardness,
-                    full_output=True)
+                    full_output=True,
+                    maxiter=1000)
                 # conversion from htol to xtol using the curvature
 
             # since the curvature was not necessarily close to
@@ -129,7 +130,7 @@ def ftweaked(r):
                 sol = scipy.optimize.root_scalar(
                     f, x0=self.r_ti,
                     fprime=fprime,
-                    options=dict(maxiter=50,
+                    options=dict(maxiter=1000,
                                  tol=1e-1 * htol / abs(
                                      fprime(
                                          self.r_ti)) * hardness)
@@ -204,7 +205,7 @@ def evaluate(self, gap, potential=True, gradient=False,
                 dV if gradient else None,
                 ddV if curvature else None)
 
-    def _lin_pot(self, gap, pot=True, gradient=False, curvature=False):
+    def _lin_pot(self, gap, potential=True, gradient=False, curvature=False):
         """ Evaluates the linear part and its derivatives of the potential.
         Parameters:
         -----------
@@ -217,7 +218,7 @@ def _lin_pot(self, gap, pot=True, gradient=False, curvature=False):
         curvature: bool, optional
             if true, returns second derivative (default False)
         """
-        V = None if pot is False else self.lin_part(gap)
+        V = None if potential is False else self.lin_part(gap)
         dV = None if gradient is False else self.lin_part[1]
         ddV = None if curvature is False else 0.
         return V, dV, ddV
diff --git a/Adhesion/System/Factory.py b/Adhesion/System/Factory.py
index 279b7900..0a1c5e80 100644
--- a/Adhesion/System/Factory.py
+++ b/Adhesion/System/Factory.py
@@ -35,14 +35,20 @@ def make_system(substrate, interaction, surface, communicator=MPI.COMM_WORLD,
     """
     Factory function for contact systems. The returned object is always
     of a subtype of SystemBase.
+
     Parameters:
     -----------
-    substrate   -- An instance of HalfSpace. Defines the solid mechanics in
-                   the substrate
-    interaction -- An instance of Interaction. Defines the contact formulation
-    surface     -- An instance of SurfaceTopography, defines the profile.
+    substrate : ContactMechanics.Substrate
+        Defines the solid mechanics in the substrate
+    interaction : Adhesion.Interaction
+        Defines the contact formulation
+    surface : SurfaceTopography.Topography
+        Defines the profile.
+
     Returns
     -------
+    system: child class of SystemBase
+
     """
 
     if interaction == "hardwall":
@@ -57,7 +63,7 @@ def make_system(substrate, interaction, surface, communicator=MPI.COMM_WORLD,
                                                physical_sizes=physical_sizes,
                                                **kwargs)
         # make shure the interaction has the correcrt communicator
-        interaction.pnp = Reduction(communicator)
+        interaction.reduction = Reduction(communicator)
         interaction.communicator = communicator
 
         return system_class(substrate, interaction, surface)
diff --git a/Adhesion/System/Systems.py b/Adhesion/System/Systems.py
index 35b13763..803beeb6 100755
--- a/Adhesion/System/Systems.py
+++ b/Adhesion/System/Systems.py
@@ -65,12 +65,23 @@ def __init__(self, substrate, interaction, surface):
             raise IncompatibleResolutionError(
                 ("the substrate ({}) and the surface ({}) have incompatible "
                  "nb_grid_ptss.").format(
-                     substrate.nb_grid_pts, surface.nb_grid_pts))  # nopep8
+                    substrate.nb_grid_pts, surface.nb_grid_pts))  # nopep8
         self.dim = len(self.substrate.nb_grid_pts)
         self.energy = None
         self.force = None
+        self.force_h = None
         self.interaction_energy = None
         self.interaction_force = None
+        self.heights_k = None
+        self.engine = self.substrate.fftengine
+
+        if hasattr(substrate.fftengine, "register_halfcomplex_field") and self.engine.communicator.size == 1:
+            # avoids the initialization to fail if we use an fftengine without these hcffts implemnented
+            # preconditionning is not parallelized yet, this we have no parallelized wrapper for hcfft in muFFT yet
+            self.real_buffer = self.engine.register_halfcomplex_field("hc-real-space", 1)
+            self.fourier_buffer = self.engine.register_halfcomplex_field("hc-fourier-space", 1)
+
+            self.stiffness_k = self._compute_stiffness_k()
 
     @property
     def nb_grid_pts(self):
@@ -94,34 +105,65 @@ def handles(substrate_type, interaction_type, surface_type, comm):
 
     def compute_repulsive_force(self):
         "computes and returns the sum of all repulsive forces"
-        return self.pnp.sum(np.where(
+        return self.reduction.sum(np.where(
             self.interaction_force > 0, self.interaction_force, 0
-            ))
+        ))
 
     def compute_attractive_force(self):
         "computes and returns the sum of all attractive forces"
-        return self.pnp.sum(np.where(
+        return self.reduction.sum(np.where(
             self.interaction_force < 0, self.interaction_force, 0
-            ))
+        ))
+
+    def _compute_stiffness_k(self):
+        """
+        computes and returns the wavevectors q that exist for the surfaces
+        physical_sizes and nb_grid_pts as one vector of components per
+        dimension
+        """
+
+        vectors = []
+        q = []
+        nb_dims = len(self.substrate.nb_grid_pts)
+        # if nb_dims == 1:
+        #     nb_grid_pts = [self.substrate.nb_grid_pts]
+        #     physical_sizes = [self.substrate.physical_sizes]
+        for dim in range(nb_dims):
+            vectors.append(2 * np.pi * np.fft.fftfreq(
+                self.substrate.nb_grid_pts[dim],
+                self.substrate.physical_sizes[dim] /
+                self.substrate.nb_grid_pts[dim]))
+        if nb_dims == 1:
+            q = vectors[0]
+            q[0] = q[1]
+        elif nb_dims == 2:
+            qx = vectors[0]
+            qy = vectors[1]
+            q = np.sqrt(
+                (qx * qx).reshape((-1, 1)) + (qy * qy).reshape((1, -1)))
+            q[0, 0] = (q[0, 1] + q[1, 0]) / 2
+
+        return 0.5 * self.substrate.contact_modulus * abs(q)
 
     def compute_normal_force(self):
         "computes and returns the sum of all forces"
-        return self.pnp.sum(self.interaction_force)
+        return self.reduction.sum(self.interaction_force)
 
     def compute_repulsive_contact_area(self):
         "computes and returns the area where contact pressure is repulsive"
-        return self.compute_nb_repulsive_pts()*self.area_per_pt
+        return self.compute_nb_repulsive_pts() * self.area_per_pt
 
     def compute_attractive_contact_area(self):
         "computes and returns the are where contact pressure is attractive"
-        return self.compute_nb_attractive_pts()*self.area_per_pt
+        return self.compute_nb_attractive_pts() * self.area_per_pt
 
     def compute_nb_contact_pts(self):
         """
         compute and return the number of contact points. Note that this is of
         no physical interest, as it is a purely numerical artefact
         """
-        return self.pnp.sum(np.where(self.interaction_force != 0., 1., 0.))
+        return self.reduction.sum(
+            np.where(self.interaction_force != 0., 1., 0.))
 
     def compute_nb_repulsive_pts(self):
         """
@@ -129,7 +171,8 @@ def compute_nb_repulsive_pts(self):
         pressure. Note that this is of no physical interest, as it is a
         purely numerical artefact
         """
-        return self.pnp.sum(np.where(self.interaction_force > 0., 1., 0.))
+        return self.reduction.sum(
+            np.where(self.interaction_force > 0., 1., 0.))
 
     def compute_nb_attractive_pts(self):
         """
@@ -137,7 +180,8 @@ def compute_nb_attractive_pts(self):
         pressure. Note that this is of no physical interest, as it is a
         purely numerical artefact
         """
-        return self.pnp.sum(np.where(self.interaction_force < 0., 1., 0.))
+        return self.reduction.sum(
+            np.where(self.interaction_force < 0., 1., 0.))
 
     def compute_repulsive_coordinates(self):
         """
@@ -158,7 +202,7 @@ def compute_mean_gap(self):
         mean of the gap in the the physical domain (means excluding padding
         region for the FreeFFTElasticHalfspace)
         """
-        return self.pnp.sum(self.gap) / np.prod(self.nb_grid_pts)
+        return self.reduction.sum(self.gap) / np.prod(self.nb_grid_pts)
 
     def logger_input(self):
         """
@@ -180,13 +224,13 @@ def logger_input(self):
                  'frac. att. area',
                  'frac. int. area', 'substrate force', 'interaction force'],
                 [self.energy,
-                 self.pnp.max(np.abs(self.force)),
+                 self.reduction.max(np.abs(self.force)),
                  self.compute_mean_gap(),
                  rel_rep_area,
                  rel_att_area,
                  rel_rep_area + rel_att_area,
-                 -self.pnp.sum(self.substrate.force),
-                 self.pnp.sum(self.interaction_force)])
+                 -self.reduction.sum(self.substrate.force),
+                 self.reduction.sum(self.interaction_force)])
 
     def evaluate(self, disp, offset, pot=True, forces=False, logger=None):
         """
@@ -219,7 +263,7 @@ def evaluate(self, disp, offset, pot=True, forces=False, logger=None):
                                       curvature=False)
 
         self.interaction_energy = \
-            self.pnp.sum(interaction_energies) * self.area_per_pt
+            self.reduction.sum(interaction_energies) * self.area_per_pt
 
         self.substrate.compute(disp, pot, forces)
         self.energy = (self.interaction_energy +
@@ -233,6 +277,7 @@ def evaluate(self, disp, offset, pot=True, forces=False, logger=None):
                 self.interaction_force
         else:
             self.force = None
+
         if logger is not None:
             logger.st(*self.logger_input())
         return (self.energy, self.force)
@@ -286,7 +331,7 @@ def fun(disp):
                     raise ValueError(
                         "{}: disp.shape: {}, res: {}".format(
                             err, disp.shape, res))
-                return (self.energy, -self.force.reshape(-1)*disp_scale)
+                return (self.energy, -self.force.reshape(-1) * disp_scale)
         else:
             def fun(disp):
                 # pylint: disable=missing-docstring
@@ -296,6 +341,551 @@ def fun(disp):
 
         return fun
 
+    def primal_evaluate(self, disp, gap, pot=True, forces=False, logger=None):
+        """
+        Compute the energies and forces in the system for a given
+        displacement and gap..
+
+        Parameters:
+        -----------
+        disp: ndarray
+            displacement field, in the shape of
+            system.substrate.nb_subdomain_grid_pts
+        gap: ndarray
+            gap , in the shape of
+            system.substrate.nb_subdomain_grid_pts
+        pot: bool, optional
+            Whether to evaluate the energy, default True
+        forces: bool, optional
+            Whether to evaluate the forces, default False
+        logger: ContactMechanics.Tools.Logger
+            information of current state of the system will be
+            passed to
+            logger at every evaluation
+        """
+        # attention: the substrate may have a higher nb_grid_pts than the gap
+        # and the interaction (e.g. FreeElasticHalfSpace)
+
+        self.gap = gap
+        interaction_energies, self.interaction_force, _ = \
+            self.interaction.evaluate(self.gap,
+                                      potential=pot,
+                                      gradient=forces,
+                                      curvature=False)
+
+        self.interaction_energy = \
+            self.reduction.sum(interaction_energies) * self.area_per_pt
+
+        self.substrate.compute(disp, pot, forces)
+        self.energy = (self.interaction_energy +
+                       self.substrate.energy
+                       if pot else None)
+        if forces:
+            self.interaction_force *= -self.area_per_pt
+            #                       ^ gradient to force per pixel
+            self.force = self.substrate.force.copy()
+
+            self.force[self.comp_slice] += self.interaction_force
+        else:
+            self.force = None
+
+        if logger is not None:
+            logger.st(*self.logger_input())
+
+        return (self.energy, self.force)
+
+    def primal_objective(self, offset, disp0=None, gradient=False,
+                         logger=None):
+        r"""To solve the primal objective using gap as the variable.
+        Can be fed directly to standard solvers ex: scipy solvers etc
+        and returns the elastic energy and it's gradient (negative of
+        the forces) as a function of the gap.
+
+        Parameters
+        __________
+
+        gap : float
+              gap between the contact surfaces.
+        offset : float
+                constant value to add to the surface heights
+        pot : (default False)
+
+        gradient : (default True)
+
+        Returns
+        _______
+        energy : float
+                value of energy(scalar value).
+        force : float,array
+                value of force(array).
+
+        Notes
+        _____
+
+        Objective:
+
+        .. math ::
+
+            \min_u f = \frac{1}{2} u_i K_{ij} u_j + \phi (u_{ij})\\
+            \\
+            \nabla f = K_{ij} u_j + \phi^{\prime} \text{    which is the force} \\
+
+        """
+
+        res = self.substrate.nb_subdomain_grid_pts
+        if gradient:
+            def fun(gap):
+                disp = gap.reshape(res) + self.surface.heights() + offset
+                try:
+                    self.primal_evaluate(
+                        disp, gap.reshape(res), forces=True, logger=logger)
+                except ValueError as err:
+                    raise ValueError(
+                        "{}: gap.shape: {}, res: {}".format(
+                            err, gap.shape, res))
+                return (self.energy, -self.force.reshape(-1))
+        else:
+            def fun(gap):
+                disp = gap.reshape(res) + self.surface.heights() + offset
+                return self.primal_evaluate(
+                    disp, gap.reshape(res), forces=False, logger=logger)[0]
+
+        return fun
+
+    def primal_hessian_product(self, gap, des_dir):
+        """Returns the hessian product of the primal_objective function.
+        """
+        _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)
+
+        hessp_val = - self.substrate.evaluate_force(
+            des_dir.reshape(self.substrate.nb_subdomain_grid_pts)
+        ).reshape(np.shape(des_dir)) \
+            + adh_curv * des_dir * self.substrate.area_per_pt
+
+        return hessp_val.reshape(des_dir.shape)
+
+    def hessian_product_function(self, offset):
+        def hessp(disp, des_dir):
+            gap = disp.reshape(self.substrate.nb_subdomain_grid_pts
+                               )[self.comp_slice] \
+                  - (self.surface.heights() + offset)
+            _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)
+            hessp_val = - self.substrate.evaluate_force(
+                des_dir.reshape(self.substrate.nb_subdomain_grid_pts)
+            )
+
+            hessp_val[self.comp_slice] += adh_curv \
+                * des_dir.reshape(
+                self.substrate.nb_subdomain_grid_pts)[self.comp_slice] * \
+                self.substrate.area_per_pt
+            return hessp_val.reshape(des_dir.shape)
+
+        return hessp
+
+    def _fourier_coefficients(self):
+        """
+        Returns the coefficients for elasticity matrix when working in fourier
+        space for both 1D and 2D system.
+        """
+
+        nx = self.substrate.nb_grid_pts[0]
+        nb_dims = len(self.substrate.nb_grid_pts)
+
+        if nb_dims == 2:
+            ny = self.substrate.nb_grid_pts[1]
+            coeffs = np.zeros(self.substrate.nb_grid_pts)
+            if np.logical_and((nx % 2 == 0), (ny % 2 == 0)):
+                coeffs[0, 0] = 1 / (nx * ny)
+                coeffs[0, 1:ny // 2] = 2 / (nx * ny)
+                coeffs[0, ny // 2 + 1:] = 2 / (nx * ny)
+                coeffs[1:nx // 2, 0] = 2 / (nx * ny)
+                coeffs[nx // 2 + 1:, 0] = 2 / (nx * ny)
+                coeffs[:nx // 2, ny // 2] = 2 / (nx * ny)
+                coeffs[nx // 2 + 1:, ny // 2] = 2 / (nx * ny)
+                coeffs[nx // 2, :ny // 2] = 2 / (nx * ny)
+                coeffs[nx // 2, ny // 2 + 1:] = 2 / (nx * ny)
+                coeffs[1:nx // 2, 1:ny // 2] = 4 / (nx * ny)
+                coeffs[nx // 2 + 1:, 1:ny // 2] = 4 / (nx * ny)
+                coeffs[1:nx // 2, ny // 2 + 1:] = 4 / (nx * ny)
+                coeffs[nx // 2 + 1:, ny // 2 + 1:] = 4 / (nx * ny)
+                coeffs[nx // 2, ny // 2] = 1 / (nx * ny)
+                coeffs[nx // 2, 0] = 1 / (nx * ny)
+                coeffs[0, ny // 2] = 1 / (nx * ny)
+            else:
+                coeffs[0, 0] = 1 / (nx * ny)
+                coeffs[0, 1:] = 2 / (nx * ny)
+                coeffs[1:, 0] = 2 / (nx * ny)
+                coeffs[1:, 1:] = 4 / (nx * ny)
+        elif nb_dims == 1:
+            coeffs = np.zeros(self.substrate.nb_grid_pts)
+            if (nx % 2 == 0):
+                coeffs[0] = 1 / nx
+                coeffs[1:nx // 2] = 2 / nx
+                coeffs[nx // 2 + 1:] = 2 / nx
+                coeffs[nx // 2] = 1 / nx
+            else:
+                coeffs[0] = 1 / nx
+                coeffs[1:] = 2 / nx
+
+        return coeffs
+
+    def evaluate_k(self, disp_k, gap, offset, mw=False, pot=True, forces=False,
+                   logger=None):
+
+        """
+        Compute the energies and forces in the system for a given displacement
+        field in fourier space.
+
+        Parameters
+        -----------
+
+        disp_k: ndarray
+            displacement field in fourier space.
+        gap:  ndarray
+            displacement field in real space, in the shape of
+            system.substrate.nb_subdomain_grid_pts
+        offset: float
+            determines indentation depth,
+            constant value added to the heights (system.topography)
+        mw: bool, optional
+            when mass weighting is required then set this to TRUE.
+        pot: bool, optional
+            Wether to evaluate the energy, default True
+        forces: bool, optional
+            Wether to evaluate the forces, default False
+        logger: ContactMechanics.Tools.Logger
+            informations of current state of the system will be passed to
+            logger at every evaluation.
+        """
+
+        # self.gap = self.compute_gap(disp, offset)
+        self.gap = gap
+        interaction_energies, self.interaction_force, _ = \
+            self.interaction.evaluate(self.gap,
+                                      potential=pot,
+                                      gradient=forces,
+                                      curvature=False)
+        self.interaction_energy = \
+            self.reduction.sum(interaction_energies) * self.area_per_pt
+
+        self.grad_k = np.zeros(self.substrate.nb_grid_pts)
+
+        coeff = self._fourier_coefficients()
+
+        if mw:
+            self.grad_k = disp_k * coeff
+        else:
+            self.grad_k = disp_k * coeff * self.stiffness_k
+
+        self.grad_k *= self.area_per_pt
+
+        # ENERGY FROM SUBSTRATE
+        self.energy = 0.5 * (np.sum(self.grad_k * disp_k))
+
+        self.substrate.energy = self.energy
+
+        self.force_h = -self.grad_k
+
+        # TOTAL ENERGY
+        self.energy += self.interaction_energy
+
+        if forces:
+            self.interaction_force *= -self.area_per_pt
+            #                     ^ gradient to force per pixel
+
+            self.real_buffer.array()[...] = self.interaction_force
+            self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+            interaction_force_float_k = self.fourier_buffer.array()[...].copy()
+
+            adh_coeffs = self._fourier_coefficients()
+            interaction_force_float_k *= adh_coeffs
+
+            if mw:
+                k = np.sqrt(self.stiffness_k.copy() * self.area_per_pt)
+                interaction_force_float_k = interaction_force_float_k * (1 / k)
+
+            self.force_h += interaction_force_float_k
+        else:
+            self.force_h = None
+
+        if logger is not None:
+            disp_real = self.gap + self.surface.heights().copy() + offset
+            force_real = self.substrate.evaluate_force(disp_real)
+            force_real = force_real + self.interaction_force
+            logger.st(*(['energy',
+                         'max. abs. grad.',
+                         'max. abs. grad. real'],
+                        [self.energy,
+                         self.reduction.max(np.abs(self.force_h)),
+                         self.reduction.max(np.abs(force_real))
+                         ]))
+
+        return (self.energy, self.force_h)
+
+    # def hessian_product_k(self, dispk, des_dir_k):
+    #     """Returns the hessian product of the fourier space
+    #     objective_k function.
+    #     """
+    #     self.substrate.fourier_buffer.array()[...] = dispk.copy()
+    #     self.substrate.fftengine.ifft(self.substrate.fourier_buffer,
+    #                                   self.substrate.real_buffer)
+    #     disp = self.substrate.real_buffer.array()[...].copy() \
+    #         * self.substrate.fftengine.normalisation
+    #
+    #     gap = self.compute_gap(disp)
+    #     _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)
+    #
+    #     self.substrate.real_buffer.array()[...] = adh_curv.reshape(
+    #         self.substrate.nb_grid_pts).copy()
+    #     self.substrate.fftengine.fft(self.substrate.real_buffer,
+    #                                  self.substrate.fourier_buffer)
+    #     adh_curv_k = self.substrate.fourier_buffer.array()[...].copy()
+    #
+    #     hessp_val_k = -self.substrate.evaluate_k_force_k(des_dir_k) + \
+    #         adh_curv_k * des_dir_k * self.substrate.area_per_pt
+    #
+    #     return hessp_val_k
+
+    # def hessian_product_preconditioned(self, offset):
+
+    #     def hessp_precond(disp_h, des_dir):
+    #
+    #         self.real_buffer.array()[...] = offset
+    #         self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+    #         offset_k = self.fourier_buffer.array()[...].copy()
+    #
+    #         self.real_buffer.array()[...] = self.surface.heights().copy()
+    #         self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+    #         self.heights_k_float = self.fourier_buffer.array()[...].copy()
+    #
+    #         disp_float_k = disp_h.copy()
+    #         disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)
+    #         gap_float_k = (disp_float_k / np.sqrt(self.stiffness_k *
+    #                                               self.area_per_pt)) - \
+    #                       self.heights_k_float - offset_k
+    #
+    #         self.fourier_buffer.array()[...] = gap_float_k.copy()
+    #         self.engine.ihcfft(self.fourier_buffer, self.real_buffer)
+    #         gap = self.real_buffer.array()[...].copy() * \
+    #               self.engine.normalisation
+    #
+    #         _, _, adh_curv = \
+    #             self.interaction.evaluate(gap,
+    #                                       curvature=True)
+    #
+    #         coeff = self._fourier_coefficients()
+    #
+    #         el_hess_k = coeff @ coeff
+    #         el_hess_k *= self.area_per_pt
+    #
+    #         orig_shape = np.shape(des_dir)
+    #
+    #         el_hess_k *= des_dir #.reshape(el_hess_k)
+    #
+    #         adh_curv *= self.area_per_pt
+    #
+    #         self.real_buffer.array()[...] = adh_curv
+    #         self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+    #         adh_curv_float_k = self.fourier_buffer.array()[...].copy()
+    #
+    #         adh_curv_float_k *= coeff @ coeff
+    #
+    #         k = np.sqrt(self.stiffness_k.copy() * self.area_per_pt)
+    #
+    #         adh_hess_k = adh_curv_float_k * des_dir * (1 / k) * (1 / k)
+    #
+    #         hess_k = el_hess_k.reshape(orig_shape) + \
+    #                  adh_hess_k.reshape(orig_shape)
+    #
+    #         return hess_k
+    #
+    #     return hessp_precond
+
+    def preconditioned_objective(self, offset, gradient=False, logger=None):
+        r"""
+        This helper method interface to the evaluate_k() method with
+        preconditioning active. That is, it tries to solve a simpler problem
+        formulated using,
+
+        original problem:
+
+        .. math ::
+
+            \frac{1}{2(n_x n_y)} \tilde{u}\tilde{K} \bar{\tilde{u}} +
+            \phi(F^{-1}(\tilde{u} - \tilde{h}))
+
+        preconditioned problem:
+
+        .. math ::
+             \tilde{v} = \tilde{k}^{\frac{1}{2}} \tilde{u} \\
+
+             \frac{1}{2(n_x n_y)} \tilde{v}\bar{\tilde{v}} +
+            \phi(F^{-1}(\frac{\tilde{v}}{\tilde{k}^{\frac{1}{2}}} - \tilde{h}))
+
+        we solve for variable :math:`\tilde{v}`.
+
+        Parameters:
+        -----------
+
+        offset: float
+            determines indentation depth,
+            constant value added to the heights (system.topography)
+        gradient: bool, optional
+            Whether to evaluate the gradient, default False
+        logger: ContactMechanics.Tools.Logger
+            information of current state of the system will be passed to
+            logger at every evaluation
+
+        Returns
+        _______
+
+            function(disp_k)
+
+                Parameters
+                __________
+
+                disp_k: an ndarray in fourier halfcomplex space
+
+                Returns
+                _______
+
+                energy: scalar
+                        energy of the system
+
+                force_h: an halfcomplex array of shape(disp_k)
+                        force of the system
+        """
+
+        self.real_buffer.array()[...] = offset
+        self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+        offset_k = self.fourier_buffer.array()[...].copy()
+
+        self.real_buffer.array()[...] = self.surface.heights().copy()
+        self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+        self.heights_k_float = self.fourier_buffer.array()[...].copy()
+
+        if gradient:
+            def fun(disp_):
+                disp_float_k = disp_.copy()
+                orig_shape = np.shape(disp_float_k)
+                disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)
+                gap_float_k = (disp_float_k / np.sqrt(self.stiffness_k *
+                                                      self.area_per_pt)) - \
+                    self.heights_k_float - offset_k
+
+                self.fourier_buffer.array()[...] = gap_float_k.copy()
+                self.engine.ihcfft(self.fourier_buffer, self.real_buffer)
+                gap = self.real_buffer.array()[...].copy() * \
+                    self.engine.normalisation
+
+                self.energy, self.force_h = self.evaluate_k(disp_float_k,
+                                                            gap, offset,
+                                                            mw=True,
+                                                            forces=True,
+                                                            logger=logger
+                                                            )
+
+                return (self.energy, -self.force_h.reshape(orig_shape))
+        else:
+            raise NotImplementedError
+
+        return fun
+
+    def objective_k_float(self, offset, gradient=False, logger=None):
+        r"""
+
+        Returns callable objective as needed by scipy minimizers.
+
+        The optimisation varialbe is the halfcomplex fourier transform of the gap.
+
+        This helper method interface to the evaluate_k() method without
+        preconditioning active.
+
+        .. math ::
+
+            \frac{1}{2(n_x n_y)} \tilde{u}\tilde{K} \bar{\tilde{u}} +
+            \phi(F^{-1}(\tilde{u} - \tilde{h}))  \\
+
+        preconditioned problem:
+
+        .. math ::
+
+             \tilde{v} = \tilde{k}^{\frac{1}{2}} \tilde{u} \\
+
+             \frac{1}{2(n_x n_y)} \tilde{v} \bar{\tilde{v}} +
+            \phi(F^{-1}(\frac{\tilde{v}}{\tilde{k}^{\frac{1}{2}}} - \tilde{h}))
+        \\
+        we solve for variable :math:`\tilde{v}`.
+
+        Parameters:
+        -----------
+
+        offset: float
+            determines indentation depth,
+            constant value added to the heights (system.topography)
+        gradient: bool, optional
+            Whether to evaluate the gradient, default False
+        logger: ContactMechanics.Tools.Logger
+            information of current state of the system will be passed to
+            logger at every evaluation
+
+        Returns
+        _______
+
+            function(disp_k)
+
+                Parameters
+                __________
+
+                disp_k: an ndarray in fourier space
+
+                Returns
+                _______
+
+                    energy, gradient_k_float
+        """
+
+        self.real_buffer.array()[...] = offset
+        self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+        offset_k = self.fourier_buffer.array()[...].copy()
+
+        self.real_buffer.array()[...] = self.surface.heights().copy()
+        self.engine.hcfft(self.real_buffer, self.fourier_buffer)
+        self.heights_k_float = self.fourier_buffer.array()[...].copy()
+
+        if gradient:
+            def fun(disp_k):
+                disp_float_k = disp_k.copy()
+                orig_shape = np.shape(disp_float_k)
+                disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)
+                gap_float_k = disp_float_k - self.heights_k_float - offset_k
+                self.fourier_buffer.array()[...] = gap_float_k.copy()
+                self.engine.ihcfft(self.fourier_buffer, self.real_buffer)
+                gap = self.real_buffer.array()[...].copy() \
+                    * self.engine.normalisation
+
+                self.energy, self.force_h = self.evaluate_k(disp_float_k,
+                                                            gap, offset,
+                                                            forces=True,
+                                                            logger=logger
+                                                            )
+                return (self.energy, -self.force_h.reshape(orig_shape))
+        else:
+            def fun(disp_k):
+                # pylint: disable=missing-docstring
+                disp_float_k = disp_k.copy()
+                disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)
+                gap_float_k = disp_float_k - self.heights_k_float - offset_k
+                self.fourier_buffer.array()[...] = gap_float_k.copy()
+                self.engine.ihcfft(self.fourier_buffer, self.real_buffer)
+                gap = self.real_buffer.array()[...].copy() \
+                    * self.engine.normalisation
+
+                return self.evaluate_k(disp_float_k, gap, offset, forces=True,
+                                       logger=logger)[0]
+
+        return fun
+
     def callback(self, force=False):
         """
         Simple callback function that can be handed over to scipy's minimize to
@@ -335,7 +925,7 @@ def compute_nb_contact_pts(self):
         """
         compute and return the number of contact points.
         """
-        return self.pnp.sum(np.where(self.gap == 0., 1., 0.))
+        return self.reduction.sum(np.where(self.gap == 0., 1., 0.))
 
     def logger_input(self):
         """
@@ -355,7 +945,7 @@ def logger_input(self):
         mask = np.ones(self.substrate.nb_subdomain_grid_pts)
         mask[self.substrate.local_topography_subdomain_slices][
             contacting_points] = 0
-        max_proj_grad = self.pnp.max(abs(mask * self.force))
+        max_proj_grad = self.reduction.max(abs(mask * self.force))
 
         return (['energy',
                  'max. proj. grad.',
@@ -373,8 +963,8 @@ def logger_input(self):
                  rel_rep_area,
                  rel_att_area,
                  rel_rep_area + rel_att_area,
-                 -self.pnp.sum(self.substrate.force),
-                 self.pnp.sum(self.interaction_force)])
+                 -self.reduction.sum(self.substrate.force),
+                 self.reduction.sum(self.interaction_force)])
 
     def compute_normal_force(self):
         "computes and returns the sum of all forces"
@@ -383,29 +973,29 @@ def compute_normal_force(self):
         # and the ineraction forces.
         # can also be computed easily from the substrate forces,
         # what we do here
-        return self.pnp.sum(
-            - self.substrate.force[self.substrate.topography_subdomain_slices])
+        return self.reduction.sum(
+            - self.substrate.force[self.substrate.local_topography_subdomain_slices])
 
     def compute_repulsive_force(self):
         """computes and returns the sum of all repulsive forces
 
         Assumptions: there
         """
-        return self.pnp.sum(
+        return self.reduction.sum(
             np.where(
                 - self.substrate.force[
-                    self.substrate.topography_subdomain_slices] > 0,
+                    self.substrate.local_topography_subdomain_slices] > 0,
                 - self.substrate.force[
-                    self.substrate.topography_subdomain_slices], 0.))
+                    self.substrate.local_topography_subdomain_slices], 0.))
 
     def compute_attractive_force(self):
         "computes and returns the sum of all attractive forces"
-        return self.pnp.sum(
+        return self.reduction.sum(
             np.where(
                 - self.substrate.force[
-                    self.substrate.topography_subdomain_slices] < 0,
+                    self.substrate.local_topography_subdomain_slices] < 0,
                 - self.substrate.force[
-                    self.substrate.topography_subdomain_slices],
+                    self.substrate.local_topography_subdomain_slices],
                 0.))
 
     def compute_nb_repulsive_pts(self):
@@ -414,12 +1004,12 @@ def compute_nb_repulsive_pts(self):
         pressure.
 
         """
-        return self.pnp.sum(
+        return self.reduction.sum(
             np.where(
                 np.logical_and(
                     self.gap == 0.,
                     - self.substrate.force[
-                        self.substrate.topography_subdomain_slices] > 0),
+                        self.substrate.local_topography_subdomain_slices] > 0),
                 1., 0.))
 
     def compute_nb_attractive_pts(self):
@@ -431,7 +1021,7 @@ def compute_nb_attractive_pts(self):
         # Compute points where substrate force is negative
         # or there is no contact
         pts = np.logical_or(- self.substrate.force[
-            self.substrate.topography_subdomain_slices] < 0,
+            self.substrate.local_topography_subdomain_slices] < 0,
                             self.gap > 0.)
 
         # exclude points where there is no contact
@@ -439,7 +1029,7 @@ def compute_nb_attractive_pts(self):
         pts[np.logical_and(self.gap > 0.,
                            self.interaction_force == 0.)] = 0.
 
-        return self.pnp.sum(pts)
+        return self.reduction.sum(pts)
 
     def compute_repulsive_coordinates(self):
         """
@@ -450,7 +1040,7 @@ def compute_repulsive_coordinates(self):
             np.logical_and(
                 self.gap == 0.,
                 - self.substrate.force[
-                    self.substrate.topography_subdomain_slices]
+                    self.substrate.local_topography_subdomain_slices]
                 > 0))
 
     def compute_attractive_coordinates(self):
@@ -462,7 +1052,7 @@ def compute_attractive_coordinates(self):
         # Compute points where substrate force is negative
         # or there is no contact
         pts = np.logical_or(
-            - self.substrate.force[self.substrate.topography_subdomain_slices]
+            - self.substrate.force[self.substrate.local_topography_subdomain_slices]
             < 0,
             self.gap > 0.)
 
diff --git a/compile_doc.sh b/compile_doc.sh
index bcf1251a..17d1da36 100755
--- a/compile_doc.sh
+++ b/compile_doc.sh
@@ -6,4 +6,5 @@ cd docs/
 rm -rf source/
 sphinx-apidoc -o source/ ../Adhesion
 make html
-open Adhesion/docs/_build/html/index.html
\ No newline at end of file
+cd ..
+open docs/_build/html/index.html
\ No newline at end of file
diff --git a/examples/preconditionning.ipynb b/examples/preconditionning.ipynb
new file mode 100644
index 00000000..2ef6b825
--- /dev/null
+++ b/examples/preconditionning.ipynb
@@ -0,0 +1,453 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.testing.exceptions\n",
+    "from SurfaceTopography.Generation import fourier_synthesis\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "from Adhesion.Interactions import RepulsiveExponential\n",
+    "from ContactMechanics import FreeFFTElasticHalfSpace, PeriodicFFTElasticHalfSpace\n",
+    "from Adhesion.System import BoundedSmoothContactSystem, SmoothContactSystem\n",
+    "import scipy.interpolate\n",
+    "import muFFT\n",
+    "from ContactMechanics.Tools.Logger import Logger\n",
+    "import time\n",
+    "import os\n",
+    "import numpy as np\n",
+    "\n",
+    "np.random.seed(0)\n",
+    "\n",
+    "Es = 1\n",
+    "hprms=0.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0\n",
+      "############# PRECONDITIONED LBFGS RUNNING #######################\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/antoines/Adhesion/Adhesion/Interactions/Exponential.py:218: RuntimeWarning: overflow encountered in exp\n",
+      "  V_rep = gam_rep * np.exp(g_rep)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL\n",
+      "1474\n",
+      "################## LBFGS REAL RUNNING ############################\n",
+      "CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL\n",
+      "4536\n",
+      "################## LBFGS HC-FOURIER RUNNING ############################\n",
+      "CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL\n",
+      "6357\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<matplotlib.colorbar.Colorbar at 0x11be17100>"
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gtol = 1e-5\n",
+    "n = 128\n",
+    "\n",
+    "w = 0.05\n",
+    "interaction_range = 1\n",
+    "\n",
+    "topography = fourier_synthesis(\n",
+    "    (n, n),\n",
+    "    (n, n),\n",
+    "    hurst=0.8,\n",
+    "    rms_slope=0.1,\n",
+    "    short_cutoff=8,\n",
+    "    long_cutoff=n/2,\n",
+    ")\n",
+    "topography = topography.scale(hprms / topography.rms_gradient()).squeeze()\n",
+    "topography._heights = topography.heights() - np.max(topography.heights())\n",
+    "\n",
+    "print(np.max(topography.heights()))\n",
+    "\n",
+    "substrate = PeriodicFFTElasticHalfSpace(\n",
+    "    (n,n), Es, physical_sizes=(n,n),\n",
+    "    fft='serial')\n",
+    "\n",
+    "interaction = RepulsiveExponential(100 * w, 0.001 * interaction_range, w, interaction_range).linearize_core(hardness=1000)\n",
+    "\n",
+    "system = SmoothContactSystem(substrate, interaction, topography)\n",
+    "\n",
+    "# TODO: This should probably end up as a method of the system\n",
+    "def fix_mw_sol(x):\n",
+    "\n",
+    "    var = x.copy()\n",
+    "    K = np.sqrt(system.stiffness_k.reshape(np.shape(x)) * system.area_per_pt)\n",
+    "    _fourier_sol_mw = var / K\n",
+    "    fourier_sol_MW = fix_fourier_sol(_fourier_sol_mw)\n",
+    "    return fourier_sol_MW\n",
+    "\n",
+    "def fix_fourier_sol(x):\n",
+    "    var = x.copy()\n",
+    "    fourier_buffer.array()[...] = var.reshape(system.nb_grid_pts)\n",
+    "    engine.ihcfft(fourier_buffer,real_buffer)\n",
+    "    real_sol = real_buffer.array()[...].copy()*engine.normalisation\n",
+    "    return real_sol\n",
+    "\n",
+    "\n",
+    "max_stress = np.max(abs(system.interaction.max_tensile))\n",
+    "topography = system.surface\n",
+    "nx, ny = system.nb_grid_pts\n",
+    "sx, sy = topography.physical_sizes\n",
+    "\n",
+    "\n",
+    "typical_stress_rep = hprms * Es\n",
+    "typical_stress_adh = abs(system.interaction.max_tensile) #w / system.interaction.rho\n",
+    "typical_stress = max(typical_stress_rep, typical_stress_adh)\n",
+    "\n",
+    "gtol_per_pixel = gtol * topography.area_per_pt #* typical_stress\n",
+    "\n",
+    "offset_temp = 1 * system.surface.rms_height_from_area()\n",
+    "\n",
+    "init_disp = np.zeros(system.substrate.nb_subdomain_grid_pts)\n",
+    "\n",
+    "engine = muFFT.FFT(system.substrate.nb_grid_pts, fft='fftw',\n",
+    "                   allow_temporary_buffer=False,\n",
+    "                   allow_destroy_input=True)\n",
+    "\n",
+    "real_buffer = engine.register_halfcomplex_field(\"real-space\", 1)\n",
+    "fourier_buffer = engine.register_halfcomplex_field(\"fourier-space\", 1)\n",
+    "real_buffer.array()[...] = init_disp\n",
+    "engine.hcfft(real_buffer, fourier_buffer)\n",
+    "k_float_disp = fourier_buffer.array()[...].copy()\n",
+    "k_float_disp_mw = k_float_disp * np.sqrt(system.stiffness_k)\n",
+    "\n",
+    "\n",
+    "\n",
+    "print('############# PRECONDITIONED LBFGS RUNNING #######################')\n",
+    "\n",
+    "sol = scipy.optimize.minimize(\n",
+    "    system.preconditioned_objective(offset_temp,gradient=True,\n",
+    "                           logger=Logger(\"evaluations_mwlbfgs.log\")),\n",
+    "x0=k_float_disp_mw,\n",
+    "method='L-BFGS-B', jac=True, bounds=None,\n",
+    "options=dict(gtol=gtol_per_pixel,\n",
+    "             ftol=0, maxcor=3,\n",
+    "             maxiter=100000,\n",
+    "             maxfun=300000,\n",
+    "             ),\n",
+    "            )\n",
+    "\n",
+    "print(sol.message)\n",
+    "print(sol.nit)\n",
+    "#assert sol.success\n",
+    "\n",
+    "#_dump(system, offset_temp, sol)\n",
+    "\n",
+    "disps = fix_mw_sol(sol.x)\n",
+    "\n",
+    "gap = system.compute_gap(disps, offset_temp)\n",
+    "plt.figure()\n",
+    "plt.colorbar(plt.imshow(gap), label=\"gap\")\n",
+    "\n",
+    "print('################## LBFGS REAL RUNNING ############################')\n",
+    "\n",
+    "sol = scipy.optimize.minimize(system.objective(offset_temp, gradient=True,\n",
+    "                                logger=Logger(\"evaluations_lbfgs.log\")),\n",
+    "    x0=init_disp,\n",
+    "    method='L-BFGS-B', jac=True, bounds=None,\n",
+    "    options=dict(gtol=gtol_per_pixel,\n",
+    "                 ftol=0, maxcor=3,\n",
+    "                 maxiter=100000,\n",
+    "                 maxfun=300000,\n",
+    "                 ),\n",
+    ")\n",
+    "\n",
+    "print(sol.message)\n",
+    "print(sol.nit)\n",
+    "#assert sol.success\n",
+    "\n",
+    "#_dump_lbfgs(system, offset_temp, sol)\n",
+    "disps = sol.x.reshape((n,n))\n",
+    "\n",
+    "gap = system.compute_gap(disps, offset_temp)\n",
+    "plt.figure()\n",
+    "plt.colorbar(plt.imshow(gap))\n",
+    "\n",
+    "print('################## LBFGS HC-FOURIER RUNNING ############################')\n",
+    "\n",
+    "sol = scipy.optimize.minimize(system.objective_k_float(offset_temp,\n",
+    "                                                       gradient=True,\n",
+    "                        logger=Logger(\"evaluations_lbfgs_fourier.log\")),\n",
+    "                              x0=k_float_disp,\n",
+    "                              method='L-BFGS-B', jac=True, bounds=None,\n",
+    "                              options=dict(gtol=gtol_per_pixel,\n",
+    "                                           ftol=0, maxcor=3,\n",
+    "                                           maxiter=100000,\n",
+    "                                           maxfun=300000,\n",
+    "                                           ),\n",
+    "                              )\n",
+    "\n",
+    "print(sol.message)\n",
+    "print(sol.nit)\n",
+    "\n",
+    "#assert sol.success\n",
+    "disps = fix_fourier_sol(sol.x)\n",
+    "\n",
+    "gap = system.compute_gap(disps, offset_temp)\n",
+    "plt.figure()\n",
+    "plt.colorbar(plt.imshow(gap))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Text(0.5, 0, 'x')"
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "# find the maximum\n",
+    "#ixs = np.argmax(topography.heights(), axis =0)\n",
+    "#iy = np.argmax(topography.heights()[ixs, range(len(ixs))])\n",
+    "#ix = ixs[iy]\n",
+    "ix, iy =  np.unravel_index(topography.heights().argmax(), topography.nb_grid_pts)\n",
+    "#plt.colorbar(ax.pcolormesh(topography.heights().T,))\n",
+    "#ax.plot(ix, iy, \"+r\")\n",
+    "\n",
+    "ax.plot(gap[ix, :])\n",
+    "ax.set_ylabel(\"gap\")\n",
+    "ax.set_xlabel(\"x\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<matplotlib.legend.Legend at 0x12027dfd0>"
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA+iUlEQVR4nO3dd5xU1dnA8d+zfWlLWxBYYAGpUqSDIIIozQIIERALKgoSCTFRI69EIbGg8TVKArFERF8VscRGNCg21GikBAUBBRGkKUWkbz/vH/fu7uzs7Myd2Zm5s7PP9/OZz86cueWZubP33HuqGGNQSimlKpLgdgBKKaVim2YUSiml/NKMQimllF+aUSillPJLMwqllFJ+JbkdQCQ0bNjQZGdnux2GUkpVKWvXrj1ojMn0To/LjCI7O5s1a9a4HYZSSlUpIrLTV7oWPSmllPJLMwqllFJ+aUahlFLKL80olFJK+aUZhVJKKb80o1BKKeWXZhRKKaX8ist+FKH62yu/Z9HRV12NoVl+ATce/pkLTpzkXzVrcGujhgBcfOw4dx/8CYAnMmrzUP16XHTsBPccPBTxmN4v7EYDOUrXhO8cLb+5qAUfFnVletLyiMRz1KRTR075fG9FYS+GJ1p9aP5bdDrdE7ZFJIZwyqnTirSj37E3uQVN87/3ucyuokyaJxzwu53va3alxYkvS14frZlNnRM7Qguqfms4rQtseg2yesPu1aXvpWVAzhHn26rZCE7st55ndoDz/wDPXVp2mcyOcGCz820GG0Ox07pArcawbSVc8nf498PwwwbrveH3wta3Yfv7Fa9ftwV0Hgenfoa1Twa//2LXroTmvUtfH90LP34Fbc8PfZsRJPE4H0WvXr1MKB3uujzVJQLRhObxfT9yXZPGZdI2fGedRLq0alGS9sKefXTMy49qbEqpMJjrkdH9b0c4trdsmgtEZK0xppd3uhY9eZAYyjNPJDg7NMcdLqeUimHH9rodgV96lvEgbgcQgK98rDDqUSilqhvNKKqQ1Wmp5dIKJdazN6VUVacZRRVyUsofLr2jUEpFmmYUVYjRmwellAs0o/AQS5XZvvKEGApPKVWNaEYRozRTUErFCs0oqhBfmYdmKEqpSNOMwoPEUAPZ2IlEKVXdaUahlFLKL80oPMTSVXwsxaKUqt40o/Cg5f1KKVWeZhQeahQmuh2CX74rs/XeQykVWZpReGiUl+J2CEqp6ixGR/PWjKIKic2fkFIq3mlGUcXpsB5KqUjTjCJG+RpORO8olIpzWvRUFcTOQZqTWb9cmvbMVkq5QTMKD7F00j2SWL4FltG5J5SKc7F0FiqlGUUZsX0ijs2fkFIq3iW5HUAgIjIGuACoAzxhjHnb3YiUUqp6ceWOQkQWi8h+EdnolT5CRL4WkW0ichuAMeZVY8x1wHRgghvxKqVUVGhldhlLgBGeCSKSCCwERgKdgEki0sljkTn2+xFjYrxwRyuzlVJucCWjMMasAn7ySu4DbDPGbDfG5AHPA6PFch/wljFmXbRjjSWaKSgV72LzvzyWKrObAbs8Xu+202YC5wHjRWR6RSuLyPUiskZE1hw4cCCkAGLzEJWK9fiUUvEp5iuzjTELgAUOlnsMeAygV69ecXlOjcsPpZQqpXUUAe0Bmnu8zrLToia2G8fiM8DY/FkppeJJLGUUq4G2ItJKRFKAicDr0Qwg1k+6OqS4UsoNbjWPXQp8CrQXkd0icq0xpgC4EVgBbAZeMMZ8FeXIoru7IBW5HYBSKsJi83LVlToKY8ykCtLfBN6McjhVWmz+rJRS8SSWip5UAJopKBXntDJbKaWUX4W5bkfgk2YUHmIzL1dKVRv7N7sdgU+aUVQhmpEpFee06KkK8DWtXAwp0n4USsW52PyP1ozCQ2weolKxHp9SqpL0jkJVlq8Od7H5s1JKxRO//ShEJAurh/TZQFPgFLAR+CfWaK7aB8xlPyTF/HBdSqkqrsI7ChF5ElgM5AH3AZOAGcBKrLkkPhaRQdEIUlkM5e8gHq9bx41QlFLViL/L0f81xmz0kb4R+Ic9HlOLyITlFqtop01eHt+mpLgcS3m+ipmKYnzYEaVU1VfhHYVnJiEi6SLS3uv9PGPMtkgG55bfHTrsdggV0joJpeJZbP6HB6zMFpGLgfXAv+zXZ4pIVEd1dVO/U6fcDqHEvqREt0NQSkVSFW71dCfWNKU/Axhj1gOtIheSe3zNmf34D6HNlhcJi+tmxOj1hlIqnjnJKPKNMUe80uL6fFVc6n96Xp6rcThhtIpCqarpo/91OwLHnGQUX4nIZUCiiLQVkb8A/45wXK57f+dunt37o6NlB5yMXvGUdw6t7ZOVqqLe/YPbETjmJKOYCZwB5ALPAUeAX0cwppjQsKiIGg7LCycfPRbhaErF9a2cUiomBcwojDEnjTG3G2N62485xpicaATnFgGuz7upXPrTe39wvI2BUbrL0IxDqXgSm//RTlo9vSMidT1e1xORFRGNKga8W9SjXFr33Nivs1BKVWFVuNVTQ2PMz8UvjDGHgUYRi8hFxYdI8D2uUjCSKjjgjQoKKrVdb7H5s1JKxRMnGUWRiJT0wBaRluj5KaB0r4zihsNHeHHPPtrl5Vdqu95fvB4IpeJJbP5HOxlR7nascZ0+xLrYPhu4PqJRxYCKDlf9wkJ+Sgzc8a12UWl7pFsOHeZKu8K7+D5lxuGfWVSvbuWCVEqpKHBSmf0voAewDHge6GmMies6iooKnVYXtSPFR5FScoByxUSPbGeinWGMP3ac+oWFQcfm3W+iskVkSikXLR7plVDB/3PeCSgMb7F1MJzOR1EI7AeOAp2qw6ixvud+kHJ1D5cfOUrfnFxe2723JG3U8RMVbnfQqRw2fPc9mYXh6QGhHe6UqsK+/zesWeyRUMFF5z1N4cWrohKSL05aPU0FVgErgHn237mRDSsW+D4D/+HgT2VeX3XkGAK0zi/g4527eOjHA9x74JCjPZyZkxt0VC/Url3mdWyWaCqlHNv1eelzf6UTW5ZHPpYKOLmjmAX0BnYaY4YA3bHHfapuDEJvr5O752HNKDIMPXmKBKCzR1PaBhXcPcx3mKF4ur9BvTKvtWe2UlVcjDaJ9eSkMjvHGJMjIohIqjFmi/eQ49VZYQVFP2OOn6B7Ti5bU5I5r4LOd94to0IR+z8xpZRzsfkf7SSj2G13uHsVeEdEDgM7IxlUVVLRxEECZBcUkB3mfhPejGglhVJVW2xmDp4CZhTGmLH207ki8j6QgT03RbyRAAVxjxZcSN+ULWXS3C76SagCt61KKT++XOZ2BAE5avUkIj1E5FdAV2C3MSYux7JItK/OBRhzZtNy779nD+tx7omTJWnhup6fEOLAglcfORqmCJRSrovRCz8nrZ7uAJ4CGgANgSdFZE6kA3PbQxO7V/jew/sP8t73u/ndocO0DFPR0pwQp1+NzZ+VUiqeOLmjmAz0NsbcaYy5E+gHXBHZsNzhs09Cs54+l80sLOLyMA8vXjuEvhWL62aENQallPLmJKPYC6R5vE4F9kQmnNggxZfp0z+BK15xNRalVHUSm2UETjKKI1iz3C0RkSeBjcDPIrJARBZENjyXndYZ0pxdsQ/MfajSu2tZULkBAwO5I9+9np2heq/wTLdDUMHK7OB2BCrMnGQUrwD/A7wPfIA1SOBrwFr7EXe8S6CeHvk0v+x8u991dpvKj7y+8IcDIa+7OSWZkwGayuaRHPL2Pd2VPzks23FiZv5MLs+bHbX9KRUTNr8BnzzsdhQlnDSPfar4uYjUA5obY76MaFQxpnuj7qQXtWE+H4V925cdOcbRRCu/rl8UWmPbYyJc2qwJQ06cZMH+g+EMz6fvw5ApOnWCdD4u6kKfnIV8nvbLqO1XKVcUlzwtu9z6O2CWa6F4ctLq6QMRqSMi9YF1wOMi8mDkQ6seZv902PHYUBXJTbDuJL5ISw163ZcLzw56nXDdmQTSO2dRyfOj1IjKPlUYxGgTTxU6J0VPGcaYo8AlwNPGmL7AeZENq+r5bPZQ1/a9Js1qayAB/j99jYi71zQIen+fFXUMep1QHKBuVPajlPLPSUaRJCJNgEsB94YvjAJ/cztkN6hJu8a1yiYml17lnpaRRiDHTeBlQvFhjXRHyxXnI5uKWjIrbwZT8m7hn4X9gt5fpObA6JbzWIXvSZRag9yQFxu3+qq6is27MScZxR+whhbfZoxZLSKtga2RDcsd+XaVzckGncu9l5acyNs3nVOacMu3cPu+kPd1Se5cn+l9TuUEva3i6Y+cnr6LEF4rGsgHRd1D+llG6qR9hFrsNg0r2GfkPVcwhFMEX3xXJf3PXjhvboQ2Hpsnuyrh2fHw8y63oyjHyQx3LxpjuhpjZtivtxtjxkU+NIuI1BSRp0TkcRGJSnObnLptKn4zw54+vKbvE5pTFZ1sn/hhf9DbKq4Cd3oC91zqO9Mk6P1FwrYia8iURNdHz4qs3+ZNp13OU4EXjIaBN8Gwu8K/3QQnY42qCn1wr9sRlFNhRiEifynuK+HrUZmdishiEdkvIhu90keIyNcisk1EbrOTLwFeMsZcB1xcmf0GDsz+6+98O3UlXPma381MdtCcM5xX5Stq1XS0XJ6xKqE9i45CrZg+asJbuXzSvpJvIj/5fD8aRU+FBJ4LvbJeLhoUtcYAfhWPgHnWTJjxWXi3PfHZym9j6B2V30ZVFYONAfzdUayhtK+Er0dlLAFGeCaISCKwEBgJdAImiUgnIAsovhcLfpLpoFgHyG8xR+3G0Hpw6evh98D4xWUW+aSoC6TWCXt0gQQqnvnOnAaEp46ha+7febXwLP8LtQlfBX/HJrUDLxSiQ8ba9l8Lxvj9blYWVjz+lxPPFrjX4KGcBI/MqlGYGyfUb135bSSmVH4bKmwqvEf07D8RbsaYVSKS7ZXcB6seZDuAiDwPjAZ2Y2UW63E+x3flBDPHQ3/nbfu3miy6yzZrF0GE0yStHftyvglijcgqvrqfnT+VMYn/rnjBZj3h23fDss+kCM67cXbuw6STyyEy6EDF5cNT829mx+gDTPvHDh5NeSjo/dxecG3IMWbnPMeOtMtCXr/QCImezeISIn/3pOKHk34UmSLygIi8KSLvFT8iEEszKPNfuttO+wcwTkT+BrzhJ87rRWSNiKw5cCD0Hs5hM2lpuaQpebeWPE8Ioijl8hZ/CktI4XaKAK24Qji5v1XYG4A/2r2/u7eoy7RBrXngF92C3pa37jmPsLywb5m06Xm/5iRpHMLJUC0Cva5mRVEfR/vbE0LT40jZYd9NAtB5XEjHBoCR95c+r98aakaq86VOyBVLnFyhPwtsBloB84AdwOoIxlSGMeaEMeZqY8wNxpgKCz+NMY8ZY3oZY3plZmZWcq9h+JFmDyyXdITS5rXJ4jU8ebuRFW4qQZxd/fmL+o/5k8msZd3Oe2dRm4taONp+JBXfpRSX3x80pSfu2aM6klUviKbF3X0PbnyYOtyYX7b560p7jpHL+ob/OxiVe2/IxTCz88vffXTPeSTkWAzC1Lzfkj/zi3JFpUGp79HQ41f/LT8W2oj5oW9b2apWHUWxBsaYJ4B8Y8yHxphrgHMjEMseoLnH6yyiPEptNA9PofdXf9nzPpcb3Hyw44u/H5OSWJ2Wyo+J5TOWIeeO5N5LutivhMv7lZ4YL8q7C27/Eaa+C5NfCrgfz8rYTwrPqHjBZD/9O2qXnxjK04C2lWhVNuqB8mmdfTfUK66TuOPCTvbrwK47u5WjMBo1Og1aBqjHCcJhQq/3Egwri3qy9kgl63raevW19f5x9p1eue0r+KJ8aUSJAnfmjHOSURQPabpPRC4Qke5A/QjEshpoKyKtRCQFmAi8HoH9BCRRmId6a1GW42WDaQRxTZPGjG3m1eT1V+sZOPQijzsK4ff2iRGggCRIToOsXmUr6n3Iadi5TOuga/JvYWDuQ0zJu6X8wkk+7gKKW9sklm35U/yN10u3qs2GdmgMQP/WdvFNcsUtu74t8vq8yWnQc0qFy3sqzrDTkq3PtLaoHd8UNWNJwbCSZRYWlG1sd/sFnQgkP6MVL8+oOJOYlneT3/U9K9X3mUj8u0VIuP53dC543075bhUYaU4yirtEJAP4LXAz8HfA/688ABFZCnwKtBeR3SJyrTGmALgRq3PfZuAFY8xXldlP8CJ/T/F4wSgm5P6eg37KxF8d/WrJ84QQ6u+PJXqtU7/4Ctj65yskgdSkRDo28XGFmuij6WaD00v6jxSm1i3zVi4p7DaN+Kioq+9gethDm9cOrr9Gg1ppfHTrEH47rL0dVxJcs8Lnsid81ZX4yFhSvL6X7Jzn8CywO71RLU6QzrC8P/GVyS5J/1PBRHtZ55Jv/Iw6aRU3g11R1JvnCwZX+L5nRrGxyNkdjBNBnX4TU+AXS0pfd/TROn1gpU4FZU3zGHRTWz3FFCcd7pYbY44YYzYaY4YYY3oaYyp1pW+MmWSMaWKMSTbGZNlFWxhj3jTGtDPGtDHG3F2ZfYSiyP46ihKdDYkRrN9f2Im7Cy7nP8arOaJXUUkbjw5/IhLSxZXPdsTNevBkwXBm5Vkttc52Wrwzcy38+ksYMZ8jo/7mbJ0ul1p1BcPvhqF3evQ98f1hiuso8sU+uUoCzevXIDHBY/mG7ZztG+DcioeFf6uwN/9uUb6IJCHEi9gr8m4rn5hsZ14trLuKinriB3LI1GZWfuVHzQ2pSfS5c+CMsaWvfdVtnBl6S6xymnhcbPS4EjqNDt+244Y7d1pOWj21E5F3izvHiUjXeJ0z+2hCPQAOZF8U2gaa+GmZUzOT8T0rKG7qc11o+/PD59wUCYnMK7iKPYRQ2S8C/W6gabMWvDi9P6/fOIC1c0rLq+8Z4zHsSXp9GPc4pNaC1Npw9m9Ki5w8t+fDEzWvg7N+5fvqtYbvIhjPzniLiouJUmpCHY/v25iS/7Eb8m/i6/ZhLEtvU7bKrszdx5mXwU2bmHPDlKA2ubaoLSdNKtfn/YaTPu6YRub67727s8h3a6QnP9nhe4VEH0OXeJd5+rrbBGh/ge9077u6tsN8L+dLUmoEhxiJA99/Zs1ZESVOyjUeB2Zj11XYc1FMjGRQrrFPJAWBp+nw7crXuDC3oiERhIz0ZGaPDG72L0EY271Z0KFUdGAHnt6Qbs3rBr09T72z69M1qy4NapWeXCb0aVm6wMzg+2MWZxvHE2rDsD9aRU1Brgtwf0HFP82uzcoX99VISeT568sOjNi3VX3Gdg9THZIIZDSjR4t6LLm6d9n1/FwdbjPN6JT7JGtNe5/vbzYtfaYXm5j3e5/p//rqB98rFFe6j17k+31/fvFk+bTJL8EvvXp8j/Jo5n3eXOg9Nfh9Kcvi4aVzVkSBk4yihjHmc6+0Ap9LVnEpSWUrNoOWXo+NpjVNi0eS7X9j6Xv2FfS0c/yMI+WDiFAjJYkHzvHRksePDyc+wQofo8o+M7Uvr/1yQFDbCpqvK//is2kNu3K683iYtoqiC63RYFrUr1FmsQp5fqe25ERnt+ONPUb4Ld7Ppb2a08+uMBf7xD1v9Bmc1cZZH4hzk59xtBzA4PbO+hxMyrudiooYvitqXOHAiZ72UTb+wEVP9hdS+zRoPaRsWiBJqXDTJrhxTWla2/OhrleT4zpZpXcZva/zfweuYoqTjOKgiLTB/tWIyHgg9GFTY1jTutaJpGMTZ/Nk+7LljyP44Bb7H2343XCzPdBu99Lcf1IfqxXw3MZ/geu8+i56tUvv1MBqYXNui+BaJP/us7nc3Liy/UkCu6Kf/yvbUvZJJy0DZu+GIbdDk24kdLkEGrTlYM9fOdvM0DvLJQXTedErmjJSk61/BwmiHPhv1w4GYFrerwH8VlB7e6Qw+CLOIXl/ZmBuBKeqFylbV1AR76KqjGbQsG3Fy/ecYt8lenzzvq4KWvSHC/9sPa+bDS0reVFTJ/i7cVWek4zil8CjQAcR2QP8GojLxtLhaJGXlpxYcmcCQK1GMGc/nFtaFHB+J6vp5460DtYwF8WufqtkgLauDa1/1t6nWcUVyQlly4cHNIvwXYFDfxzTmR3zLyBgJVuSfWLJyLLqLRLs7yi1Nsxcw9FWo5ztMCkFfvk5XPZiSZLDG4oyjH2S8jzmiyb34Ffnnm7NO+KvD0ixeq1of1ptDIYVRX3ok7OQOQXXOI5hp2dvaQ/fFvnvY1KsS87fHe/L85RcUOhjhF4fJ+3juQUcOZVfftkrXoGZa8qnB81HRnHNv6CX/R0mJMDohWHYTxSMjODoCct/U/r8p+2R248ffjMKe6C+GcaY84BMoIMxZqAxZmdUoouykpNHuFsWJKWWOSMVb7/c/2bLs6COdZIwfq6S66fV529DHbY+ihX1smH8kwF7Bfv73CUy20O70orRhrVKM9Gr+ju9w7F4HuusejX4zbD2Vj+aTmP8rzjlTbj2HStmO+T91AtYv/Xs1L48PPHMcumbilryn6IOZOc8R7vT2/K/v+jGI5f38LutY0FMD+tZ9PT5dz9RVFTR9yyQPQiAq1cmMPC+96DXtdDNo3VTm3PLFysFUvx9nnGJ9TcxxWrV1KxXcNvx56yZ5dP6zQjf9v3pe31ktrvrc1jzROlrf53xIshvRmGMKQQG2s9PGGOORSUqt0W4BVqC3Q7TX9n6fWffx7i24zijQfmez10zuyIiLBoaQsWjD7/wbo1VfPeT0QImv+xsI05uxzpf4qflUuhfep2hpZ395o32aH1VJibDtEHWcBqLJvcoOblX2CQ2IRHm7GfzFV+WJLXJ9GjFkz0AallFe8F0iBxwekNGn9mML+4Yxurbz+Ofhda4UWPz5jEhzxpa+5mpfRnXM4sRnZvwxo3lh4IJhWdGcdnf/8PjH20nv7CIPT+fKlmiRNvzYPYeVpsOHMspgAsfhLEhXpgUzwLZxi6OvehhuGW7dWeYXg+uCzBoZHo9Z/uZe6Ts3Bpzj1iPs8rXaYVdKA0AnHrifP/vvxedXgROip7+KyKvi8gVInJJ8SPikcWxgac35LqzW3FPyZAa5TWv05y5Z80lyWMSmMXDravxrFrWib1n454+1w3W6Y28pnjtZrcc6j+j/JANsajbBEeLdc2qy475FzCqSxOKfBQ9lZOUSsc2LXn9xgEsubo3z1/f3+dinndBZzSt4/OOwVtGjWQya6fym/wZDMr9M8/PGOxzuS5ZzuvLJuT+njNzHmVAzsM+Yixr2/7j3PHaRgbMf88qXmpq373UtovDUr1+E6G69Tu43aOlVWIS1AxisMT0utY2+kwrm97hQt+d/W79Dm7eFlKoQet5NVz+j/D2JQnI60iuut/3YmHmpA1iGnCIsuM7GaxRXeNK8T982IuevCQmiKNhILz1Pq03Dw1+iLOzzo5AVB4ysqypMpOdF22UaOq/uKQi9e3hRfq2CnHE1anvwkGvodjPnwcv2eXdGc3LvNUr27pSHXB64BZEXbPq+n2/fePafLb9J1775QC6ZmUENQRMLil8bxrTvUU9PrntXPILgpvh7978SUxNepOHCy4p6cj5M+XHc1pXVL6z4gdfW6MsH88tIOPc31vjYYV7bopkH73mg1WjPoy6H4b8DyydBN//u3RypI//XH5Zb4NujcwJNXsgnB5Dc4xEUMCMwhhzdTQCiQUFRVar36QYnspxaMvSH2aKk2EO/Izm2b9NAx5btZ0eLX3c3qc4mzWvhIh1sm4QXPPfYs3qpvP+zYNpXi/IXvHt7PmvsnpZD0+dx1mPzW9A2+Fl3urZsj6b/zCC9JTKz8tw+wWdGNWlSUj9U5rVTWfaOa1Lngfr0cKLeDRA66kRufP51pStIH9x7e6yCyUmOWvtFAnn/xGOVdC/w1N6XbjqDSjyqmDPDJC5nXs7HP8R1tlT7Ay9E96dF1Korlv3NFxY/o4x0io8I9q9rxcZY3yOQiUi52L1sVgeqeCirTij8G5hFKscZWj9bqjwrSHtG7HpD8OpkRKmjNH7RB2kVg2DzJzm7Hc2P3NH3yfScGQSYPW/6ds6tDuhT26LxEDMlivzfkceyWwx/iuejdtTbw5w2DQarAzNszPm3CPO1hsx38oopr4HWT2rbkYBVqYXZf7qKDYAb9jDd/xJRG4VkTtE5P9EZANwEfCf6IQZHfn2lUos31EE61TBKb/vhy2TcENSqs7U5seqom58VhS4iPOVdVEdzd8dKTWsTCXLrtfr63EBNfklaHKm//VHL4JLnDdHjqg1lZhPJEQVZhTGmNeMMQOw+kx8BSQCR4FngD7GmJuMMTEwlVz4NKtldc5JT4rMoICRMKT5EL/v/+q9IK7WVEx656ZBJc/vHxf+4qFHV7nTNt9VIz2KZJt0s+dieRmS0stXnAN0nwxdxsM5PgaA9NS0cvOqxyondRRbga1RiMV1Dw5+kHU/rqNheiUmzYmyUa1H8f6u9yt8/7N9n1X4nqoa2jauTfcWdfnv9z/TxruFWhgcz43LEXkCazkAdn4CKbWs4qy258GcH6CoED5/tHS5oVazZURgyGzY8CL89K3H8P22X2+0KtNTasLL18GGFyIUePSLCoOf7CCOZaRmMKSF/yt0pdxQXI0gAv/5H6tBw9ltG5LdwGqZNqqL717eTn34TVwVDjgz5Z9wx09WsZQnz+LMuUfg7N+WfX/mWpi5ruyoCgB1m5c2Ahn3uJVxRIIJrmVcOGhGUcUNaDqAtvX8jLGj4kLpqAHQuE4aH94ymMVTSkejvWV4cKMSe7tqsfe4n9WASMV1XGMfs4aKqWg9J6376jaHiRHoSR1jldmqCqidUpt/XBx3XVqUl3aNrb4RGelWi7yWDWqS7D2ToQqfbhOsoWIqq8Oo0mFLwuW/XiMWH/jG93Jh5K957F/wUxhmjNFaUqWi5I9jOnNJjyxaZ4a/jkJFWKTn/97wot8ZHcPB3yXJGmAtVs/sHlgV2luBMwGd0FapKEpLTqS/jzkyWjSwysRTk/TuImb1idCAgd4KcmHLPyOyaX/NY58yxjwFdAUGG2P+Yoz5CzAUK7NQMeS3PX8beCEVd/4yqTuPXdGTpiH06lZR0qIfjH20bJpnb/JbtsPtlah3KB6e5K5G8PxlsPPT0LdVASeXIfWAOh6va9lpKoaMau1wPgcVVzLSkxl2RuVaPKko6DaxbOspz/lOajYIz5hYxU4dDt+2bE4yivlYI8guEZGngHXAPWGPRFVKomgPZVWqU5M6gRfy8u9vD0YgElWidpPS54Nvg9rOJqhypKgwfNvyIWBGYYx5EugLvII1Ymx/u0hKxZB4GnZEhaaXx+COA9s2JC05uHqLtzb8wJodPzFz6X99z4KnKqfXtaXP2w2Hqe/ApU+HZ9uFeR4vwt8hz+kvKRdrnuzDQDsRGRRgeRVlekehRp9pXaE2rJXCzcPas3bO+fRp5XuiKF/+77OdjH/kU974Yi87Dp2IVJjVV4LX6TYjy5rlLxw8B3aMQIe8gBmFiEwFVgErgHn237lhj0RVSqo92f1Vna5yORLlGrsZ5vAzTiMlKYGaqUm8MM33ZEsONha+uFSpic/BRQvCv90NpXPIk+NwRN0gOCmvmAX0Bj4zxgwRkQ5oHUXMSU5M5uOJH1MzuSbH84/z8laHU5iquNG1mTUb3tlty45V1qxuuseUp87888t9YYtLeehwQWS2+4ZHt7YIDBvvpOgpxxiTAyAiqcaYLUAYuiyqcMtIzSApIank7kJVL92a12XjvOGM6NykTHooc178eWXke/uqqsNJRrFbROoCrwLviMhrwM5IBqUqp4bHFKYZqc7nXFZVX61UbdRQZY35W3i240YdhTFmrDHmZ2PMXOD3wBPAmLBHosImLbG0TXaRCyNNqtjz5dxhboegAjnzMrjufWg3spIbinLRk4gkisiWkt0b86Ex5nVjTJ6/9ZS7Ckzp/ALH8o6x/Ug1nJhGlVEnrWpM71vtNesBLc+q3DaiXUdhjCkEvhYR/5PuqphS6NX5ZsIbE1yKRCkVtEpP7+tOZXY94Ct77uzXix9hj0RFTE5hjtshKKWcOmNs5daPwB2Fk5qv34d9r0qpqKtfM4WfTgRfamyMQSI9VLYqVVGrxbNvho8ecLABFzIKY8yHYd+rUirq2jeuzafbD5GenMipfOdjA2354RgdQxg7SoWookz5tM7O1nejH4WIHBORo16PXSLyioi0DntEqtIu73Q5g7J0lBVV1v9e2g2AR6/oGWDJsgqLwn/iUQ417WH9bdINN3vLO6mjeAi4BWgGZAE3A88BzwOLIxaZCln9tPosHLqQGkml/SlOFZzi0jcu5csDX7oYmXJT07rp7Jh/AYPaZQa1XgQuUJU/qbVLn1/+MtxxGK7/MPIz5fnhJKO42BjzqDHmmDHmqDHmMWC4MWYZOi9FTDtZcLLk+TeHv2HzT5uZ//l8FyNSsWLg6Q1JcHjeySssJPu2f/LX97ZGNihlSUyGuUesR4361mCCIji+o2jSLewhOckoTorIpSKSYD8uBYqb0ei1RhVRPLqsdsBTAM9M7cv2e52NO3Q816rPeOLj7yIZkgrE6R1FUUHgZYLkJKOYDFwB7Ad+tJ9fLiLpwI1hj0iFzR397yh5/t/9/wVAdFRQFSRjlz0dPpnvciTKkYbtwr5JJ0N4bDfGXGSMaWiMybSfbzPGnDLGfBz2iHwQkTEi8riILBMRHYvAodFtSse6v3/1/S5GomLVnycELqbQYoNY4fAir2bDwMsEKbgpsEIgIotFZL+IbPRKHyEiX4vINhG5zd82jDGvGmOuA6YD2s3YoZTElHJp2h5eeaqbXv434u2rPeGf30CFoMHpru064hkFsAQY4ZkgIonAQmAk0AmYJCKdRKSLiCz3ejTyWHWOvZ5yqHuj7m6HoGJY8/o1Ai7z6vq9UYhEBVT7tLKvb4neGG4RH5PYGLNKRLK9kvsA24wx2wFE5HlgtDHmXuBC722IdRk8H3jLGLMuwiHHlT6n9SmpnwCto1Blnd6oVsBltu0/HoVIVNBqNojarpx0uJslInXE8oSIrAtDPUEzYJfH6912WkVmAucB40VkegVxXi8ia0RkzYEDByoZXvx4/VuvYbk0n1Be7r2ki9shKEfcqy1yUvR0jTHmKDAMq9/EFVhX91FjjFlgjOlpjJlujHmkgmUeM8b0Msb0yswMrkNRPOvc0GG3f1Vt6WRHKhAnGUXxNego4P+MMV9R+evSPUBzj9dZdpoKs8s7Xl7m9cn8k+WGIVfVW1EQXa9fW6//ptWRk4xirYi8jZVRrBCR2kBle22tBtqKSCsRSQEmAjp0eQR0ySxbrLDt523c+/m9LkWjqrpZz693OwTlAicZxbXAbUBvY8xJIAW42ukORGQp8CnQXkR2i8i1xpgCrM56K4DNwAv2nYoKsyQpX6yw7OtlLkSiYtU5QY799OE3WgdY3TgZZrzIbrV0uYgY4GNjzCtOd2CMmVRB+pvAm063o0Kj/SZUIDWDrKP4au+RoDMXFQYSjd4Mvjlp9bQIq6PbBmAjME1EtC9DFbdixwq3Q1AxIkEvJqqGtAxoO9yVXTvJos7FGi32SWPMk1h1FUMjG5aKtH999y+3Q1AxwukossV02HEXjXbnGt1JRrENaOHxujmg4w1XcQURGGFSVU1aPFmF1Mq0MotfPGW9nvBsVHZbYeGkiLyB1cOjNrBZRD63X/cFPo9KdCpi+jXt53YISqlQdPdo8p49MCq79FeL5WQWb1VF1UoOPHSDUr4YLXuKHel1vV5HZi65CouejDEf+ntEJBoVEfPOmlcubc4ncxj96mhyCnJ8rKFUxTSfiDFjHy19PuOziOzCSaunfiKyWkSOi0ieiBSKyNGIRKMi4pK2l/hM335kO0ZnG1BB0l9MjOk2sfS59wizYeKkMvuvwCSsCux0YCo61HfcSErQcX4UtHAw3HixTXv1OrG6cdSDwxizDUg0xhTaTWRHBFpHVQ2+em6r6ueFaf1pWCuVv14WeP6Sf331QxQiUrHEyVnipD0e03oRuR/YR3QmPFJRoE0jFcBpGWmsmXMex3J0XmxVnpMT/hX2cjcCJ7D6UYyLZFBKKXdo/UMV1aHcfG9h5WSsp5320xygfPMZVSWc3/J8th7eyo6jO9wORSkVbhMj2/FOi5CqiQcHP8gVna5wOwwV4+qkJTO+Z5bbYagYoxlFNTL69NFMaD/B7TBUjLt6QHbAZQ4dz418ICpmOOlHkeYjrWFkwlGRlJqYypx+c9wOQ8U4cTCBZc+7VlJUpDUa1YWTO4rVIlIyMJCIjAP+HbmQVLQsGrrI7RBUFbZpn/anqC6cNI+9DFgsIh8ATYEGWEOPqyouPSnd7RCUUlWAk1ZPG0TkbuD/gGPAIGPM7ohHpiJOh+9QvmjXGuUtYEYhIk8AbYCuQDtguYj8xRijw3gopVQ14KSOYgMwxBjznTFmBdZ8FD0iG5aKpE4NOgE6XLTyr2lGuXYsqpoKmFEYYx4yHmcUY8wRY8y1kQ1LRVLrjNYApCXpiUCVV79mCgDnd2rsciQqVjhpHttWRF4SkU0isr34EY3gVGTM6TeHuwfeTdfMrm6HomJQ4zppvPfbc5hzYSe/y933ry1Riki5zUnR05PA34ACYAjwNPBMJINSkVUzuSYXt7nY7TBUDGudWYvkRP+nh4+2HoxSNMptTjKKdGPMu4AYY3YaY+YCF0Q2LKVUVTDq4Y84lVfodhgqwpxkFLkikgBsFZEbRWQsoBMuK6XYtO8oEx+PzPSbKnY4yShmATWAXwE9sYYdvyqSQSmlqo69P59yOwQVYU463K22nx4Hro5sOJGTn5/P7t27ycnJcTsUFQZpaWlkZWWRnJzsdijVwnkdG7Ny848+3ztwzBogcOOeI9RISaR1phY4xBsnHe56AbcDLT2XN8ZUqSYzu3fvpnbt2mRnZ+usblWcMYZDhw6xe/duWrVq5XY41ULrzJqwueL3f/PCev6xbg8AO+ZrFWa8cTLW07PALVgd74oiG07k5OTkaCYRJ0SEBg0acODAAbdDqRaSEwP/zxRnEio+OckoDhhjXo94JFGgmUT80GMZHRvmDiNBhI+2Os+Udx46QcsGNSMYlYo2J5XZd4rI30VkkohcUvyIeGRKKdfVTkumZmoSIzo3oU+r+o7WOedPH0Q2KBV1Tu4orgY6AMmUFj0Z4B+RCkr5lp2dzZo1a2jYUOeNUtHXuI4O+VJdOckoehtj2kc8kmrGGIMxhoQEnY1WVQ1dmtXhjS/2uh2GcoGTjOLfItLJGLMp4tFEybw3vmLT3vDOztWpaR3uvOgMv8vs2LGD4cOH07dvX9auXcull17K8uXLyc3NZezYscybNw+AMWPGsGvXLnJycpg1axbXX399WGNVKhRTB7bmnjd1fKfqyElG0Q9YLyLfAbmAAKaqNY+NFVu3buWpp57i6NGjvPTSS3z++ecYY7j44otZtWoVgwYNYvHixdSvX59Tp07Ru3dvxo0bR4MGDdwOXVVzCQnagKC6cpJRjIh4FFEW6Mo/klq2bEm/fv24+eabefvtt+nevTsAx48fZ+vWrQwaNIgFCxbwyiuvALBr1y62bt2qGYVSyjVOembvjEYg1UXNmlazQWMMs2fPZtq0aWXe/+CDD1i5ciWffvopNWrUYPDgwdqbXCnlKq1Jdcnw4cNZvHgxx48fB2DPnj3s37+fI0eOUK9ePWrUqMGWLVv47DMdcE0p5S4nRU8qAoYNG8bmzZvp378/ALVq1eKZZ55hxIgRPPLII3Ts2JH27dvTr18/lyNVSlV3VSKjEJGawIfAXGPMcrfjCVV2djYbN24seT1r1ixmzZpVbrm33nrL5/o7duyIVGhKKVWhiBY9ichiEdkvIhu90keIyNcisk1EbnOwqd8BL0QmSqWUUv5E+o5iCfBXrOlTARCRRGAhcD6wG1gtIq8DicC9XutfA3QDNgHaLVSpKsIYo+NxxZGIZhTGmFUiku2V3AfYZozZDiAizwOjjTH3Ahd6b0NEBgM1gU7AKRF50xhTZUexVao6eG39XsZ0b+Z2GCpM3KijaAbs8ni9G+hb0cLGmNsBRGQKcLCiTEJErgeuB2jRokW4YlVKeWhQM4VDJ/ICLudkGVV1VJnmscaYJf4qso0xjxljehljemVmZkYzNKWqjTdmDnS03LGc/AhHoqLJjYxiD9Dc43WWnaaUinFN66Y7Wu6hlVsjHImKJjcyitVAWxFpJSIpwEQgLiZGCmTBggV07NiRyZMnV3pbo0aN4ueff658UEopFUBE6yhEZCkwGGgoIruBO40xT4jIjcAKrJZOi40xX0UyjlixaNEiVq5cSVZWVsjbKB6e/M033wxqvcLCQhITE0Per1Kq+op0q6dJFaS/CQR3pgunt26DHzaEd5undYGR8yt8e/r06Wzfvp2RI0cyZcoUPvroI7Zv306NGjV47LHH6Nq1K3PnzqVWrVrcfPPNAHTu3Jnly61qGc/hyd98803OOeeckkmMnnnmGRYsWEBeXh59+/Zl0aJFJCYmUqtWLaZNm8bKlStZuHAhAwc6K19Wyp///v58uv/xHbfDUFFUZSqzq7pHHnmEpk2b8v7777Njxw66d+/Ol19+yT333MOVV14ZcP2tW7cyY8YMvvrqK1q2bFmSvnnzZpYtW8Ynn3zC+vXrSUxM5NlnnwXgxIkT9O3bly+++EIzCRU29WqmuB2CirIqMYRH2Pm58o+Gjz/+mJdffhmAc889l0OHDnH0qP+JlIqHJ/f27rvvsnbtWnr37g3AqVOnaNSoEQCJiYmMGzcuzNErpaqb6plRxKikpCSKikq7iXgOL148PLk3YwxXXXUV997r3akd0tLStF5CKVVpWvTkgrPPPrukeOiDDz6gYcOG1KlTh+zsbNatWwfAunXr+O677wJua+jQobz00kvs378fgJ9++omdO3UKERVZfxh9Br/oGXqjDFW16B2FC+bOncs111xD165dqVGjBk899RQA48aN4+mnn+aMM86gb9++tGvXLuC2OnXqxF133cWwYcMoKioiOTmZhQsXlqnHUCrcruyfDcCLa3e7G4iKCs0ooshzmPBXX3213Pvp6em8/fbbPtf1HJ7ce1sTJkxgwoQJ5dYpnhRJKaUqQ4uelFJK+aUZhVJKKb80o1BKKeWXZhRKqZB9cPNgxuq8E3FPMwqlVMiyG9bkzxPOdDsMFWGaUSilKm3jvOFuh6AiSDOKam7JkiXceOONgDUe1dNPP12Svnfv3pLlpk6dyqZNm1yJce7cuTzwwAOu7Fs5Uys1iUt6aBFUvNJ+FDHGzeHAp0+fXvJ8yZIldO7cmaZNmwLw97//3ZWYVNVx50Vn8I91OgdZPKqWGcV9n9/Hlp+2hHWbHep34Hd9fud3mR07djBixAh69uzJunXrOOOMM3j66afp1KkTEyZM4J133uHWW2+lfv363HnnneTm5tKmTRuefPJJatWqxerVq5k1axYnTpwgNTWVd999l+TkZG644QbWrFlDUlISDz74IEOGDGHJkiW8/vrrnDx5km+//ZaxY8dy//33A/Dkk09y7733UrduXbp160ZqaipAyTDn2dnZrFmzhsmTJ5Oens6nn37KyJEjeeCBB+jVqxdLly7lnnvuwRjDBRdcwH333QdArVq1mDVrFsuXLyc9PZ3XXnuNxo0bM2XKFOrUqcOaNWv44YcfuP/++xk/fjwAf/rTn3jhhRfIzc1l7NixzJs3D4C7776bp556ikaNGtG8eXN69uwZ1uOlwi8jPdntEFSEaNFTlH399dfMmDGDzZs3U6dOHRYtWgRAgwYNWLduHeeddx533XUXK1euZN26dfTq1YsHH3yQvLw8JkyYwMMPP8wXX3zBypUrSU9PZ+HChYgIGzZsYOnSpVx11VUlgwmuX7+eZcuWsWHDBpYtW8auXbvYt28fd955J5988gkff/yxz+Kk8ePH06tXL5599lnWr19Penrp9Jd79+7ld7/7He+99x7r169n9erVJb3MT5w4Qb9+/fjiiy8YNGgQjz/+eMl6+/bt4+OPP2b58uXcdtttALz99tts3bqVzz//nPXr17N27VpWrVrF2rVref7551m/fj1vvvkmq1evjtThUEo5UC3vKAJd+UdS8+bNGTBgAACXX345CxYsACgZguOzzz5j06ZNJcvk5eXRv39/vv76a5o0aVIynHidOnUAa8jymTNnAtChQwdatmzJN998A1gDBmZkZADWmFA7d+7k4MGDDB48mMzMzJL9Fi/vxOrVq8usP3nyZFatWsWYMWNISUnhwgsvBKBnz568807p5DZjxowhISGBTp068eOPPwJWRvH222/TvXt3wBpyZOvWrRw7doyxY8dSo0YNAC6++GLH8Sl3zRjchkUffOt2GCrMqmVG4SYR8fm6eBhxYwznn38+S5cuLbPchg3Bz8hXXKQE1twUBQUFQW8jGMnJySWfx3t/nrEYY0r+zp49m2nTppXZzkMPPRTROFXkdG6W4XYIKgK06CnKvv/+ez799FMAnnvuuXIzz/Xr149PPvmEbdu2AVZxzjfffEP79u3Zt29fSTHMsWPHKCgoKDNk+TfffMP3339P+/btK9x/3759+fDDDzl06BD5+fm8+OKLPperXbs2x44dK5fep08fPvzwQw4ePEhhYSFLly7lnHPOCf6LwJredfHixSWDF+7Zs4f9+/czaNAgXn31VU6dOsWxY8d44403Qtq+ir6RnU8DYMpZ2e4GosJKM4ooa9++PQsXLqRjx44cPnyYG264ocz7mZmZLFmyhEmTJtG1a1f69+/Pli1bSElJYdmyZcycOZNu3bpx/vnnk5OTw4wZMygqKqJLly5MmDCBJUuWlLl699akSRPmzp1L//79GTBgAB07dvS53JQpU5g+fTpnnnkmp06dKrP+/PnzGTJkCN26daNnz56MHj06pO9i2LBhXHbZZfTv358uXbowfvx4jh07Ro8ePZgwYQLdunVj5MiRJcVtKvaJCOnJiSQnSuCFVZUhxcUA8aRXr15mzZo1ZdI2b95c4UkxWnbs2MGFF15YbshwFZpYOKaqvJuWrWfg6Q0ZpxMbVTkistYY08s7XesolFJhpUN6xB8teoqi7OxsvZtQSlU51SqjiMditupKj6VS0VNtMoq0tDQOHTqkJ5g4YIzh0KFDpKWluR2KUtVCtamjyMrKYvfu3Rw4cMDtUFQYpKWlkZWllaVKRUO1ySiSk5Np1aqV22EopVSVU22KnpRSSoVGMwqllFJ+aUahlFLKr7jsmS0iB4CdIa7eEDgYxnBimX7W+FSdPitUr88b6c/a0hiT6Z0YlxlFZYjIGl9d2OORftb4VJ0+K1Svz+vWZ9WiJ6WUUn5pRqGUUsovzSjKe8ztAKJIP2t8qk6fFarX53Xls2odhVJKKb/0jkIppZRfmlEopZTySzMKDyIyQkS+FpFtInKb2/EES0Sai8j7IrJJRL4SkVl2en0ReUdEttp/69npIiIL7M/7pYj08NjWVfbyW0XkKrc+UyAikigi/xWR5fbrViLyH/szLRORFDs91X69zX4/22Mbs+30r0VkuEsfJSARqSsiL4nIFhHZLCL94/XYishN9m94o4gsFZG0eDm2IrJYRPaLyEaPtLAdRxHpKSIb7HUWiEjl56U1xujDqqdJBL4FWgMpwBdAJ7fjCvIzNAF62M9rA98AnYD7gdvs9NuA++zno4C3AAH6Af+x0+sD2+2/9ezn9dz+fBV85t8AzwHL7dcvABPt548AN9jPZwCP2M8nAsvs553sY50KtLJ/A4luf64KPutTwFT7eQpQNx6PLdAM+A5I9zimU+Ll2AKDgB7ARo+0sB1H4HN7WbHXHVnpmN3+0mLlAfQHVni8ng3MdjuuSn6m14Dzga+BJnZaE+Br+/mjwCSP5b+2358EPOqRXma5WHkAWcC7wLnAcvsf4yCQ5H1MgRVAf/t5kr2ceB9nz+Vi6QFk2CdP8UqPu2NrZxS77JNgkn1sh8fTsQWyvTKKsBxH+70tHulllgv1oUVPpYp/nMV222lVkn373R34D9DYGLPPfusHoLH9vKLPXFW+i4eAW4Ei+3UD4GdjTIH92jPuks9kv3/EXr6qfNZWwAHgSbuo7e8iUpM4PLbGmD3AA8D3wD6sY7WW+D22EL7j2Mx+7p1eKZpRxCERqQW8DPzaGHPU8z1jXWZU+TbRInIhsN8Ys9btWKIkCau44m/GmO7ACawiihJxdGzrAaOxMsemQE1ghKtBRVEsHkfNKErtAZp7vM6y06oUEUnGyiSeNcb8w07+UUSa2O83Afbb6RV95qrwXQwALhaRHcDzWMVPDwN1RaR4Qi7PuEs+k/1+BnCIqvFZwboy3G2M+Y/9+iWsjCMej+15wHfGmAPGmHzgH1jHO16PLYTvOO6xn3unV4pmFKVWA23tlhUpWJVir7scU1Ds1g1PAJuNMQ96vPU6UNwq4iqsuovi9CvtlhX9gCP27e8KYJiI1LOv7obZaTHDGDPbGJNljMnGOlbvGWMmA+8D4+3FvD9r8Xcw3l7e2OkT7ZYzrYC2WJWBMcUY8wOwS0Ta20lDgU3E4bHFKnLqJyI17N908WeNy2NrC8txtN87KiL97O/uSo9thc7tSp1YemC1MPgGq3XE7W7HE0L8A7FuWb8E1tuPUVjlte8CW4GVQH17eQEW2p93A9DLY1vXANvsx9Vuf7YAn3swpa2eWmOdDLYBLwKpdnqa/Xqb/X5rj/Vvt7+DrwlDC5EIfs4zgTX28X0Vq7VLXB5bYB6wBdgI/B9Wy6W4OLbAUqy6l3ysO8Vrw3kcgV729/Yt8Fe8GkCE8tAhPJRSSvmlRU9KKaX80oxCKaWUX5pRKKWU8kszCqWUUn5pRqGUUsovzSiU8kNE/m3/zRaRy8K87f/xtS+lYo02j1XKAREZDNxsjLkwiHWSTOnYRL7eP26MqRWG8JSKKL2jUMoPETluP50PnC0i6+25EhJF5E8istqeJ2CavfxgEflIRF7H6k2MiLwqImvt+RWut9PmA+n29p713JfdC/dPYs3FsEFEJnhs+wMpnZPi2bDMNaBUAEmBF1FKYQ3AV3JHYZ/wjxhjeotIKvCJiLxtL9sD6GyM+c5+fY0x5icRSQdWi8jLxpjbRORGY8yZPvZ1CVYv7G5AQ3udVfZ73YEzgL3AJ1hjIH0c7g+rlCe9o1AqNMOwxuBZjzWUewOssYQAPvfIJAB+JSJfAJ9hDeTWFv8GAkuNMYXGmB+BD4HeHtvebYwpwhqiJTsMn0Upv/SOQqnQCDDTGFNmQD27LuOE1+vzsCbMOSkiH2CNTRSqXI/nhej/sIoCvaNQypljWNPLFlsB3GAP646ItLMnEvKWARy2M4kOWFNUFssvXt/LR8AEux4kE2vqzFgd9VRVA3o1opQzXwKFdhHSEqy5L7KBdXaF8gFgjI/1/gVMF5HNWCOYfubx3mPAlyKyzlhDpBd7BWuqzy+wRgO+1Rjzg53RKBV12jxWKaWUX1r0pJRSyi/NKJRSSvmlGYVSSim/NKNQSinll2YUSiml/NKMQimllF+aUSillPLr/wF575GXy/jGcgAAAABJRU5ErkJggg==\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "\n",
+    "data_real = np.loadtxt(\"evaluations_lbfgs.log\", comments=\"#\")\n",
+    "ax.plot(data_real[:,1], label=\"real\")\n",
+    "\n",
+    "data_fourier = np.loadtxt(\"evaluations_lbfgs_fourier.log\", comments=\"#\")\n",
+    "ax.plot(data_fourier[:,-1], label=\"fourier\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "data_precond = np.loadtxt(\"evaluations_mwlbfgs.log\", comments=\"#\")\n",
+    "ax.plot(data_precond[:,-1], label=\"preconditionned\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "ax.set_xlabel(\"iteration\")\n",
+    "ax.set_ylabel(\"max abs grad (realspace)\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "\n",
+    "ax.legend()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<matplotlib.legend.Legend at 0x120271ee0>"
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "\n",
+    "\n",
+    "final_energy = data_real[-1,0]\n",
+    "ax.plot(data_real[:,0] - final_energy, label=\"real\")\n",
+    "\n",
+    "ax.plot(data_fourier[:,0] - final_energy, label=\"fourier\")\n",
+    "\n",
+    "ax.plot(data_precond[:,0] - final_energy, label=\"preconditionned\")\n",
+    "\n",
+    "ax.set_xlabel(\"iteration\")\n",
+    "ax.set_ylabel(\"Excess energy\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "\n",
+    "ax.legend()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/examples/sinewave_bem_vs_jkr.py b/examples/sinewave_bem_vs_jkr.py
new file mode 100644
index 00000000..711cdb49
--- /dev/null
+++ b/examples/sinewave_bem_vs_jkr.py
@@ -0,0 +1,177 @@
+import numpy as np
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from SurfaceTopography import UniformLineScan
+import matplotlib.pyplot as plt
+
+from Adhesion.Interactions import VDW82, Exponential
+from Adhesion.System import SmoothContactSystem, BoundedSmoothContactSystem
+from Adhesion.ReferenceSolutions.sinewave import JKR
+
+# %% [markdown]
+#
+# # Smooth against JKR
+#
+
+# %%
+
+s = 1.
+
+Es = 1. / np.pi
+alpha = 0.2  # nondimensionalized stress intensity factor
+w = alpha ** 2 / (2 * Es)
+
+fig, ax = plt.subplots()
+ax.set_title("comparison against analytical")
+a = np.linspace(0, 0.4)
+ax.plot(np.sin(np.pi * a) ** 2 - alpha * np.sqrt(np.tan(np.pi * a)), a * 2,
+        "--k", label="JKR limit")
+
+ax.set_xlabel(R"mean pressure ($\pi E^* h / \lambda$)")
+ax.set_ylabel("frac. contact area (-)")
+
+for p in [6, 8, 10, 12]:
+    n = 2 ** p
+    dx = s / n
+    z0 = 2 * np.sqrt(dx)
+
+    inter = VDW82(w * z0 ** 8 / 3, 16 * np.pi * w * z0 ** 2
+                  ).spline_cutoff(gamma=w
+                                  ).linearize_core()
+
+    substrate = PeriodicFFTElasticHalfSpace((n,), young=Es,
+                                            physical_sizes=(s,),
+                                            fft='serial')
+
+    surface = UniformLineScan(
+        np.cos(np.arange(0, n) * np.pi * 2. / n),
+        physical_sizes=(s,))
+
+    system = SmoothContactSystem(substrate, inter, surface)
+
+    offsets = np.linspace(-2, 0.35, 20)
+    offsets = np.concatenate((offsets, offsets[-2::-1]))
+
+    contact_areas = np.zeros_like(offsets)
+    mean_pressures = np.zeros_like(offsets)
+
+    nsteps = len(offsets)
+    disp0 = None
+    gtol = 1e-5
+    i = 0
+    for offset in offsets:
+        if disp0 is not None:
+            disp0 += offset - offset_prev  # noqa: F821
+        sol = system.minimize_proxy(
+            disp0=disp0,
+            options=dict(gtol=gtol * max(Es * surface.rms_gradient(), abs(
+                inter.max_tensile)) * surface.area_per_pt,
+                         # max absolute value of the gradient
+                         # of the objective for convergence
+                         ),
+            # logger=Logger("laststep.log"),
+            method="L-BFGS-B",
+            offset=offsets[i],
+            callback=None,
+            lbounds="auto"
+            )
+        assert sol.success, sol.message
+        disp0 = sol.x
+        mean_pressures[i] = system.compute_normal_force() / s
+        contact_areas[i] = np.count_nonzero(system.gap < inter.r_infl) / n
+
+        # print("step {}".format(i))
+        offset_prev = offset
+        i += 1
+    abserror = np.max(abs(
+        mean_pressures - JKR.mean_pressure(contact_areas / 2, alpha)))
+    ax.plot(mean_pressures, contact_areas,
+            label="n={}, error={:.1e}".format(n, abserror))
+
+    plt.pause(0.0001)
+ax.grid()
+ax.legend()
+plt.show()
+
+# %% [markdown]
+#
+# # Hardwall against JKR
+#
+
+# %%
+
+s = 1.
+
+Es = 1. / np.pi
+alpha = 0.2  # nondimensionalized stress intensity factor
+w = alpha ** 2 / (2 * Es)  # = alpha^2 np.pi / 2
+
+fig, ax = plt.subplots()
+ax.set_title("comparison against analytical")
+a = np.linspace(0, 0.4)
+ax.plot(JKR.mean_pressure(a, alpha), a * 2, "--k", label="JKR limit")
+
+ax.set_xlabel(R"mean pressure ($\pi E^* h / \lambda$)")
+ax.set_ylabel("frac. contact area (-)")
+
+for p in [6, 8, 10, 12]:
+    n = 2 ** p
+    dx = s / n
+    rho = np.sqrt(dx)
+
+    inter = Exponential(w, rho)
+
+    substrate = PeriodicFFTElasticHalfSpace((n,), young=Es,
+                                            physical_sizes=(s,),
+                                            fft='serial')
+
+    surface = UniformLineScan(
+        np.cos(np.arange(0, n) * np.pi * 2. / n),
+        physical_sizes=(s,), periodic=True)
+
+    system = BoundedSmoothContactSystem(substrate, inter, surface)
+
+    offsets = np.linspace(-2, 0.35, 20)
+    offsets = np.concatenate((offsets, offsets[-2::-1]))
+
+    contact_areas = np.zeros_like(offsets)
+    mean_pressures = np.zeros_like(offsets)
+
+    nsteps = len(offsets)
+    disp0 = None
+    gtol = 1e-5
+    i = 0
+    for offset in offsets:
+        if disp0 is not None:
+            disp0 += offset - offset_prev
+        sol = system.minimize_proxy(
+            disp0=disp0,
+            options=dict(gtol=gtol * max(Es * surface.rms_gradient(), abs(
+                inter.max_tensile)) * surface.area_per_pt,
+                         # max absolute value of the gradient
+                         # of the objective for convergence
+                         ),
+            # logger=Logger("laststep.log"),
+            method="L-BFGS-B",
+            offset=offset,
+            callback=None,
+            lbounds="auto"
+            )
+        assert sol.success, sol.message
+        disp0 = sol.x
+        mean_pressures[i] = system.compute_normal_force() / s
+        contact_areas[i] = system.compute_contact_area() / s
+
+        # print("step {}".format(i))
+        offset_prev = offset
+        i += 1
+
+    abserror = np.max(abs(
+        mean_pressures - JKR.mean_pressure(contact_areas / 2, alpha)))
+    ax.plot(mean_pressures, contact_areas,
+            label="n={}, error={:.1e}".format(n, abserror))
+
+    plt.pause(0.0001)
+
+ax.grid()
+ax.legend()
+plt.show()
diff --git a/helpers/check_gradient_energy.py b/helpers/check_gradient_energy.py
new file mode 100644
index 00000000..bd5a851e
--- /dev/null
+++ b/helpers/check_gradient_energy.py
@@ -0,0 +1,88 @@
+from SurfaceTopography import make_sphere
+from SurfaceTopography.Generation import fourier_synthesis
+import Adhesion.Interactions as Inter
+from Adhesion.System import SmoothContactSystem
+import ContactMechanics as Solid
+import numpy as np
+
+
+
+
+
+nx = 32
+
+sx = sy = 2
+R = 10.
+Es = 50.
+
+interaction = Inter.RepulsiveExponential(0, 0.5, 0, 1.)
+
+substrate = Solid.PeriodicFFTElasticHalfSpace((nx,), young=Es,
+                                              physical_sizes=(sx,))
+
+topography = make_sphere(R, (nx,), (sx,), kind="paraboloid")
+
+system = SmoothContactSystem(substrate=substrate, surface=topography,
+                             interaction=interaction)
+
+
+def check_fun_grad_consistency(fun,
+        x0 , dx=None,
+        hs=np.array([1e1, 1, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5,1e-6, 1e-7])):
+    """
+    Tests the consistency between the function and its gradient values.
+
+    Parameters
+    _________
+
+    fun:  callable function returning fun and gradient at x.
+    x:  value to test at.
+    """
+
+    obj = fun
+
+    x = x0
+    if dx is None: 
+        dx = 1 * (0.5 + np.random.random(size=(x0.shape)))
+    dx *= np.linalg.norm(dx) # make it a unit vector 
+
+    en, grad = obj(x)  
+
+    taylor = []
+
+    for h in hs:
+        _en, _grad = obj(x + h * dx)
+        _taylor = _en - en - np.sum(grad * h * dx)
+        _taylor = _taylor/h**2
+        if not taylor :
+            _max_taylor = _taylor
+            lower_bnd = _max_taylor/10
+            upper_bnd = _max_taylor*10
+        taylor.append(_taylor)
+        np.testing.assert_array_less(lower_bnd,_taylor,err_msg='lower bound not met.')
+        np.testing.assert_array_less(_taylor,upper_bnd,err_msg='upper bound not met.')
+
+    if True :
+        # Visualize the quadratic convergence of the taylor expansion
+        # What to expect:
+        # Taylor expansion: g(x + h ∆x) - g(x) = Hessian * h * ∆x + O(h^2)
+        import matplotlib.pyplot as plt
+        fig, ax = plt.subplots()
+        ax.plot(hs, taylor, "+-")
+        ax.set_xscale("log")
+        ax.set_xlabel('hs')
+        ax.set_yscale("log")
+        ax.set_ylabel('taylor diff')
+        ax.grid(True)
+        plt.show()
+
+
+obj_float = system.objective_k_float(0, True, True)
+obj_real = system.objective(0, True, True)
+
+x = np.random.uniform(size=nx) 
+# dx = np.zeros(nx)
+# dx[8]=1
+
+check_fun_grad_consistency(obj_real, x)
+check_fun_grad_consistency(obj_float, x)
diff --git a/requirements.txt b/requirements.txt
index 54d7fdec..efb062ec 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,18 +1,17 @@
 igor
 matplotlib>=1.0.0
 numpy>=1.16.3
-pylint>0.25
 pep8>=0.6
 scipy>=1.2.0
 netCDF4>=1.5.3
 h5py
 sphinx>=1.8.2
-NuMPI>=0.1.1
+NuMPI>=0.1.6
 pytest>=4
 pytest-flake8
 flake8
 sphinx_rtd_theme
 setuptools_scm>=3.5.0
-muFFT>=0.11.1
+muFFT>=0.14.0
 runtests>=0.0.28
-ContactMechanics>=0.90.1
+git+https://github.com/ComputationalMechanics/ContactMechanics.git@feat/20_objective
diff --git a/setup.py b/setup.py
index aa18ab93..a8026d19 100755
--- a/setup.py
+++ b/setup.py
@@ -52,7 +52,7 @@
     install_requires=[
         'numpy>=1.11.0',
         'NuMPI',
-        'muFFT',
+        'muFFT>=0.14.0',
         'SurfaceTopography',
         'ContactMechanics',
     ]


Test patch:
diff --git a/long_tests/__init__.py b/long_tests/__init__.py
new file mode 100644
index 00000000..e40dbfbe
--- /dev/null
+++ b/long_tests/__init__.py
@@ -0,0 +1,29 @@
+#
+# Copyright 2020 Antoine Sanner
+#           2020 Lars Pastewka
+#
+# ### MIT license
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+"""
+Testing Module for Adhesion
+
+These are long tests
+"""
diff --git a/long_tests/conftest.py b/long_tests/conftest.py
new file mode 100644
index 00000000..992d5e91
--- /dev/null
+++ b/long_tests/conftest.py
@@ -0,0 +1,73 @@
+#
+# Copyright 2019-2020 Antoine Sanner
+#           2019-2020 Lars Pastewka
+#
+# ### MIT license
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+import pytest
+
+from runtests.mpi.tester import WorldTooSmall, create_comm
+
+import NuMPI
+from NuMPI import MPI
+
+
+def MyMPITestFixture(commsize, scope='function'):
+    """
+    Create a test fixture for MPI Communicators of various communicator
+    sizes.
+    """
+
+    @pytest.fixture(params=commsize, scope=scope)
+    def fixture(request):
+        MPI.COMM_WORLD.barrier()
+        # Return an NuMPI stub communicator if we don't have mpi4py
+        if not NuMPI._has_mpi4py:
+            return MPI.COMM_SELF
+
+        # Try creating a communicator and fallback to NuMPI stub
+        try:
+            comm, color = create_comm(request.param)
+
+            if color != 0:
+                pytest.skip("Not using communicator {}."
+                            .format(request.param))
+                return None
+            else:
+                # Turn a None into a NuMPI stub communicator
+                if comm is None:
+                    comm = MPI.COMM_SELF
+                print('MPI communicator: Rank {} (of {}).'
+                      .format(comm.rank, comm.size))
+                return comm
+
+        except WorldTooSmall:
+            pytest.skip("Not using communicator {}.".format(request.param))
+            return None
+
+    return fixture
+
+
+comm = MyMPITestFixture([1, 4], scope='session')
+comm_self = MyMPITestFixture([1], scope='session')
+
+maxcomm = MyMPITestFixture([MPI.COMM_WORLD.Get_size()], scope="session")
diff --git a/long_tests/test_bugnicourt_bench_reduced.py b/long_tests/test_bugnicourt_bench_reduced.py
new file mode 100644
index 00000000..2b13266d
--- /dev/null
+++ b/long_tests/test_bugnicourt_bench_reduced.py
@@ -0,0 +1,133 @@
+# This aims to make a strong test for CGs using the simulation in figure 3 of
+# the Bugnicourt paper for approx 20% contact area.
+# Note that they use a nonadhesive simulation result to initialize the fields
+# which is not done in this test.
+# Bugnicourt, R., Sainsot, P., Dureisseix, D. et al. FFT-Based Methods for
+# Solving a Rough Adhesive Contact Tribol Lett 66, 29 (2018).
+# https://doi.org/10.1007/s11249-017-0980-z
+import pytest
+from SurfaceTopography.Generation import fourier_synthesis
+from matplotlib import pyplot as plt
+
+from Adhesion.Interactions import Exponential
+from Adhesion.System import make_system, BoundedSmoothContactSystem
+import numpy as np
+from NuMPI.Optimization import ccg_without_restart
+from NuMPI import MPI
+import scipy.optimize as optim
+
+pytestmark = pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                                reason="tests only serial funcionalities, "
+                                       "please execute with pytest")
+
+
+def test_bug_bench():
+    # Remark:
+    #
+    # This test fails right now.
+    # But my guess is that the contact is multistable and LBFGS-B and Bugnicourt sample different metastable states.
+    #
+    # For lower adhesion the two algorithms are in good agreement.
+
+    np.random.seed(0)
+    # nondim we use
+    Es = 1.
+    # rms_curvature = 1.
+    w = 1.
+    n = 2048
+
+    # Rc ** 2/3 (w / Es)**(1/3)
+    lateral_unit = (60e-9 ** (2 / 3) * (5e-3 / 25e6) ** (1 / 3))
+
+    s = 4e-6 / lateral_unit
+
+    # dx = s / n
+
+    long_cutoff = s * 1 / 4
+    short_cutoff = s * 0.1 / 4
+
+    topo = fourier_synthesis(nb_grid_pts=(n, n),
+                             hurst=0.8,
+                             physical_sizes=(s, s),
+                             rms_slope=1,
+                             long_cutoff=long_cutoff,
+                             short_cutoff=short_cutoff,
+                             )
+
+    topo = topo.scale(1 / topo.rms_curvature_from_area()).squeeze()
+
+    # Adhesion parameters:
+
+    tabor = 3.0
+    interaction_length = 1 / tabor  # original was 1/tabor.
+
+    interaction = Exponential(w, interaction_length)
+    # process_zone_size = Es * w / np.pi / abs(interaction.max_tensile) ** 2
+
+    system = make_system(interaction=interaction,
+                         surface=topo,
+                         substrate='periodic',
+                         young=Es,
+                         system_class=BoundedSmoothContactSystem)
+
+    print("max height {}".format(np.max(system.surface.heights())))
+
+    gtol = 1e-4
+
+    disp0 = np.zeros(topo.nb_grid_pts)
+
+    penetration = 30.0
+
+    init_gap = disp0 - system.surface.heights() - penetration
+
+    lbounds = np.zeros((n, n))
+    bnds_gap = system._reshape_bounds(lbounds, )
+
+    # lbounds = system._lbounds_from_heights(penetration)
+    # bnds_disp = system._reshape_bounds(lbounds, )
+
+    sol = optim.minimize(system.primal_objective(penetration, gradient=True), init_gap,
+                         method='L-BFGS-B', jac=True, bounds=bnds_gap,
+                         options=dict(gtol=gtol * max(Es * topo.rms_gradient(),
+                                                      abs(interaction.max_tensile)) * topo.area_per_pt, ftol=0,
+                                      maxcor=3), callback=None)
+
+    print(sol.message, sol.nfev)
+    assert sol.success, sol.message
+    # sol_lbfgs = sol
+    mask = sol.x == 0
+    area_lbfgs = mask.sum()
+    print('lbfgsb frac ar. {}'.format(area_lbfgs / n ** 2))
+    sol_lbfgs = sol.x
+    # iter_lbfgsb = sol.nfev
+    # mean_val_lbfgs = np.mean(sol.x)
+
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=None,
+        gtol=gtol * max(Es * topo.rms_gradient(), abs(interaction.max_tensile)) * topo.area_per_pt,
+        maxiter=1000)
+
+    print(res.message, res.nit)
+    assert res.success
+    sol_bug = res.x
+    mask = sol_bug == 0
+    area_cg = mask.sum()
+    print('cg frac ar. {}'.format(area_cg / n ** 2))
+
+    print('min {} and max {} lbfgs'.format(np.min(sol_lbfgs), np.max(sol_lbfgs)))
+    print('min {} and max {} bug'.format(np.min(sol_bug), np.max(sol_bug)))
+
+    fig, ax = plt.subplots()
+    ax.set_aspect("equal")
+
+    levels = np.linspace(0, np.max(sol_lbfgs), 5)
+    plt.colorbar(ax.contour(sol_lbfgs.reshape((n, n)), linewidths=0.1, levels=levels))
+    ax.contour(sol_bug.reshape((n, n)), linestyles="dashed", linewidths=0.1, levels=levels)
+
+    fig.savefig("gaps.pdf")
+
+    assert area_cg == area_lbfgs
+
+    np.testing.assert_allclose(sol_lbfgs, sol_bug, atol=1e-2)
diff --git a/test/test_sphere_vdw82_mpi.py b/long_tests/test_sphere_vdw82_mpi.py
similarity index 98%
rename from test/test_sphere_vdw82_mpi.py
rename to long_tests/test_sphere_vdw82_mpi.py
index be87969e..72b5bcea 100644
--- a/test/test_sphere_vdw82_mpi.py
+++ b/long_tests/test_sphere_vdw82_mpi.py
@@ -37,11 +37,11 @@
 from Adhesion.Interactions import VDW82
 from Adhesion.System import SmoothContactSystem
 
+from ContactMechanics.Tools.Logger import screen
+
 _toplot = True
 
 
-# TODO problem: difficult to compare contact_area with MD Model,
-@pytest.mark.skip("is very slow, call it explicitely")
 def test_smoothsphere(maxcomm):
     """
     This test needs a lot of computational effort
@@ -106,7 +106,7 @@ def test_smoothsphere(maxcomm):
     normal_force = []
     area = []
     for i in range(nsteps):
-        result = LBFGS(system.objective(offsets[i], gradient=True),
+        result = LBFGS(system.objective(offsets[i], gradient=True, logger=screen),
                        disp0, jac=True, pnp=pnp, gtol=1e-6 * abs(w / z0))
 
         # result = system.minimize_proxy(
diff --git a/test/ReferenceSolutions/test_sphere_jkr.py b/test/ReferenceSolutions/test_sphere_jkr.py
index 00d82735..a2187311 100644
--- a/test/ReferenceSolutions/test_sphere_jkr.py
+++ b/test/ReferenceSolutions/test_sphere_jkr.py
@@ -208,7 +208,7 @@ def test_energy_release_rate_derivatives_against_sif_derivatives():
         # Irwin:
         sif / Es
         * JKR.stress_intensity_factor(contact_radius=contact_radius, penetration=penetration, der="1_d"),
-        atol=1e-14, rtol=0
+        atol=1e-13, rtol=0
         )
 
     np.testing.assert_allclose(
@@ -220,7 +220,7 @@ def test_energy_release_rate_derivatives_against_sif_derivatives():
                 + JKR.stress_intensity_factor(contact_radius=contact_radius, penetration=penetration, der="1_d") *
                 JKR.stress_intensity_factor(contact_radius=contact_radius, penetration=penetration, der="1_a")
         ),
-        atol=1e-14, rtol=0
+        atol=1e-13, rtol=0
         )
     np.testing.assert_allclose(
         JKR.nonequilibrium_elastic_energy_release_rate(
@@ -230,7 +230,7 @@ def test_energy_release_rate_derivatives_against_sif_derivatives():
                 sif * JKR.stress_intensity_factor(contact_radius=contact_radius, penetration=penetration, der="2_a")
                 + JKR.stress_intensity_factor(contact_radius=contact_radius, penetration=penetration, der="1_a") ** 2
         ),
-        atol=1e-14, rtol=0
+        atol=1e-13, rtol=0
         )
 
 
diff --git a/test/test_bugnicourt_primal_rough_weakly_adhesive.py b/test/test_bugnicourt_primal_rough_weakly_adhesive.py
new file mode 100644
index 00000000..819397f4
--- /dev/null
+++ b/test/test_bugnicourt_primal_rough_weakly_adhesive.py
@@ -0,0 +1,308 @@
+"""
+
+Runs the  primal (gap as DOFS) ccg_without_restart algorithm with fixed penetration
+and with constrained mean gap. Compares the gaps with the old serial lbfgsb
+code with displacements as variables
+
+"""
+
+from NuMPI.IO import load_npy
+from SurfaceTopography.IO.NPY import NPYReader
+from SurfaceTopography.Generation import fourier_synthesis
+from Adhesion.Interactions import Exponential
+from ContactMechanics.Systems import NonSmoothContactSystem
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from Adhesion.System import make_system, BoundedSmoothContactSystem
+from NuMPI.Optimization.ccg_without_restart import constrained_conjugate_gradients
+from NuMPI.Tools import Reduction
+
+import os
+import numpy as np
+from NuMPI import MPI
+
+_comm = MPI.COMM_WORLD
+Es = 1.
+
+gtol = 1e-8
+
+n = 512
+dx = 1.
+s = n
+
+rms_slope = 0.1
+
+penetration = 0.1
+
+# interaction parameters
+elastocapillary_length = 0.005 * dx
+w = Es * elastocapillary_length
+# Interaction range as in P&R PNAS
+# with some modifications
+rho = dx / 4
+# P&R keep the interaction parameters and vary h'rms,
+# We keep h'rms constant and hence need to vary the interaction
+# parameters accordingly
+
+interaction = Exponential(w, rho)
+
+
+def get_topography_file(_comm):
+    """
+    generates the topography for the tests
+    """
+
+    print("topography fixture")
+    path = "topography.npy"
+    if _comm.rank == 0:
+        if not os.path.exists(path):
+            np.random.seed(0)
+            full_topography = fourier_synthesis((n, n), (s, s),
+                                                0.8,
+                                                rms_slope=rms_slope,
+                                                long_cutoff=s / 2,
+                                                short_cutoff=32,
+                                                )
+            full_topography._heights = full_topography.heights() - np.max(
+                full_topography.heights())
+
+            np.save(path, full_topography.heights())
+
+    _comm.barrier()
+    return path
+
+
+def get_reference_data_file(_comm):
+    """
+    computes a reference solution using lbfgsb. Is serial, so cannot be done
+    inside the parallel test
+    """
+    print("reference fixture")
+    path = "reference_gap.npy"
+    if _comm.rank == 0:
+        if not os.path.exists(path):
+            system = make_system(interaction=interaction,
+                                 surface="topography.npy",
+                                 substrate="periodic",
+                                 physical_sizes=(n, n),
+                                 young=Es, communicator=MPI.COMM_SELF,
+                                 system_class=BoundedSmoothContactSystem
+                                 )
+            print("computing reference")
+            sol = system.minimize_proxy(
+                offset=penetration,
+                lbounds="auto",
+                options=dict(
+                    ftol=0,
+                    gtol=1e-5 * max(Es * rms_slope, abs(
+                        interaction.max_tensile)) * system.surface.area_per_pt,
+                    maxcor=3,
+                    maxiter=1000,
+                    )
+
+                )
+
+            assert sol.success
+            gap = system.compute_gap(
+                disp=sol.x,
+                offset=penetration)
+            np.save(path, gap)
+            print("finished computing reference")
+    _comm.barrier()
+
+    return path
+
+
+def test_ccg_without_restart_weakly_adhesive(comm, verbose=False):
+    topography_file = get_topography_file(comm)
+    reference_data_file = get_reference_data_file(comm)
+    _penetration = penetration
+    pnp = Reduction(comm)
+
+    substrate = PeriodicFFTElasticHalfSpace(
+        nb_grid_pts=(n, n),
+        physical_sizes=(n, n),
+        young=Es,
+        fft="mpi",
+        communicator=comm)
+
+    # topography = Topography(
+    #     full_topography.heights(),
+    #     physical_sizes=(n, n),
+    #     decomposition="domain",
+    #     nb_subdomain_grid_pts=substrate.nb_subdomain_grid_pts,
+    #     subdomain_locations=substrate.subdomain_locations,
+    #     communicator=comm,
+    #     )
+
+    print("reading topography")
+    topography = NPYReader(topography_file, communicator=comm).topography(
+        physical_sizes=(n, n),
+        nb_subdomain_grid_pts=substrate.nb_subdomain_grid_pts,
+        subdomain_locations=substrate.subdomain_locations)
+
+    tol = 1e-5 * topography.rms_height_from_area()
+    forcetol = 10 * gtol * max(Es * rms_slope, abs(
+        interaction.max_tensile)) * topography.area_per_pt
+    system = make_system(interaction=interaction,
+                         surface=topography,
+                         substrate=substrate,
+                         system_class=BoundedSmoothContactSystem,
+                         communicator=comm)
+    substrate = system.substrate
+
+    if verbose:
+        print("""
+        Some informations on the system
+        """
+              )
+
+        process_zone_size = Es * w / np.pi / abs(interaction.max_tensile) ** 2
+
+        print("nb pixels in process zone: {}".format(process_zone_size / dx))
+        # print("highcut wavelength / process_zone size: "
+        #       "{}".format(short_cutoff / process_zone_size))
+        print("rms_height / interaction_length: "
+              "{}".format(topography.rms_height() / rho))
+
+        print("Persson and Tosatti adhesion criterion: ")
+        print(
+            "elastic deformation energy for full contact / work of adhesion: "
+            "{}".format(substrate.evaluate(topography.detrend().heights())[0]
+                        / w / np.prod(topography.physical_sizes)))  # ^
+        #            sets the mean to zero, so         |
+        #            that the energy of the q = 0   --
+        #            mode is not taken into
+        #            account
+
+        # P&R equation 10, with kappa_rep = 2, d_rep=4 h'rms / h''rms
+        # (Only valid in the DMT regime, i.e. until the onset of stickiness)
+        # If this value is smaller then 1 the surfaces are sticky and
+        # normal CG's might not work anymore
+        print("P&R stickiness criterion: "
+              "{}".format(rms_slope * Es * rho / 2 / w *
+                          (rms_slope ** 2 / topography.rms_curvature() / rho)
+                          ** (2 / 3)))
+
+        R = 1 / topography.rms_curvature()
+        print("Generalized Tabor parameter à la Martin Müser")
+        print("{}".format(
+            R ** (1 / 3) * elastocapillary_length ** (2 / 3) / rho))
+
+    reference_gap = load_npy(
+        reference_data_file,
+        subdomain_locations=substrate.subdomain_locations,
+        nb_subdomain_grid_pts=substrate.nb_subdomain_grid_pts,
+        comm=comm
+        )
+
+    print("""
+    ########## PENETRATION CONTROLLED ##################
+    """)
+
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    init_gap = init_disp - topography.heights() - _penetration
+    init_gap[init_gap < 0] = 0
+
+    res = constrained_conjugate_gradients(
+        system.primal_objective(_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=None,
+        gtol=gtol * max(Es * rms_slope, abs(
+            interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000,
+        communicator=comm,
+        )
+
+    print(res.nit)
+
+    assert res.success, res.message
+    gap = res.x.reshape(substrate.nb_subdomain_grid_pts)
+
+    assert pnp.max(abs(gap - reference_gap)) < tol
+
+    forces_ref = substrate.evaluate_force(
+        gap + topography.heights() + _penetration)
+
+    print("""
+    ########## mean_gap controlled #################
+    """)
+
+    mean_gap = pnp.sum(gap) / np.prod(substrate.nb_domain_grid_pts)
+
+    # typical initial guess
+
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    _penetration = pnp.sum(
+        init_disp - topography.heights() - mean_gap) / np.prod(
+        substrate.nb_domain_grid_pts)
+
+    print(_penetration)
+
+    init_gap = init_disp - topography.heights() - _penetration
+    init_gap[init_gap < 0] = 0
+
+    res = constrained_conjugate_gradients(
+        system.primal_objective(_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol * max(Es * rms_slope, abs(
+            interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000,
+        communicator=comm,
+        )
+
+    assert res.success, res.message
+    gap = res.x.reshape(substrate.nb_subdomain_grid_pts)
+    print(res.nit)
+
+    max_abs_error = pnp.max(abs(gap - reference_gap))
+    assert max_abs_error < tol, "{} >= tol = {}".format(max_abs_error, tol)
+
+    # just check that I am still able to compute the correct pressures
+    grad = system.primal_objective(0, gradient=True)(
+        gap)[1].reshape(substrate.nb_subdomain_grid_pts)
+
+    nc_points = gap > 0
+    nb_nc_points = pnp.sum(np.count_nonzero(nc_points))
+    lagrange_mean_gap = pnp.sum(grad[nc_points]) / nb_nc_points
+
+    forces = substrate.evaluate_force(gap + topography.heights()) + lagrange_mean_gap
+
+    max_abs_error = pnp.max(abs(forces - forces_ref))
+    assert max_abs_error < forcetol, \
+        "{} >= tol = {}".format(max_abs_error, forcetol)
+
+    print("""
+    #########   NONADHESIVE, same mean gap #############
+    """)
+    nonadh_system = NonSmoothContactSystem(substrate=substrate,
+                                           surface=topography)
+
+    res = constrained_conjugate_gradients(
+        nonadh_system.primal_objective(_penetration, gradient=True),
+        nonadh_system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol * max(Es * rms_slope, abs(
+            interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000,
+        communicator=comm,
+        )
+
+    assert res.success, res.message
+    gap_nonadh = res.x
+    print(res.nit)
+
+    if verbose and comm.Get_size() == 1.:
+        import matplotlib.pyplot as plt
+        from matplotlib.colors import LinearSegmentedColormap
+
+        fig, ax = plt.subplots()
+
+        contactcmap = LinearSegmentedColormap.from_list('contactcmap', (
+            (1, 1, 1, 0.), (1, 0, 0, 1)), N=256)
+        ax.imshow(gap.reshape(substrate.nb_grid_pts) == 0, cmap=contactcmap)
+
+        contactcmap = LinearSegmentedColormap.from_list('contactcmap', (
+            (1, 1, 1, 0.), (0, 1, 0, 1)), N=256)
+        ax.imshow(gap_nonadh.reshape(substrate.nb_grid_pts) == 0,
+                  cmap=contactcmap)
diff --git a/test/test_ccg_without_restart.py b/test/test_ccg_without_restart.py
new file mode 100644
index 00000000..e7b0c3ca
--- /dev/null
+++ b/test/test_ccg_without_restart.py
@@ -0,0 +1,321 @@
+from NuMPI.Tools import Reduction
+from SurfaceTopography import make_sphere
+import ContactMechanics as Solid
+from SurfaceTopography.Generation import fourier_synthesis
+from ContactMechanics.Tools.Logger import Logger
+from Adhesion.Interactions import Exponential
+from Adhesion.System import BoundedSmoothContactSystem
+from NuMPI.Optimization import ccg_without_restart
+import numpy as np
+import scipy.optimize as optim
+import pytest
+from NuMPI import MPI
+
+
+@pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                    reason="tests only serial funcionalities,"
+                           " please execute with pytest")
+def test_force_computation_mean_gap_constrained():
+    pnp = np
+    nx, ny = 32, 32
+    # FIXED by the nondimensionalisation
+    # maugis_K = 1.
+    Es = 3 / 4  # maugis K = 1.
+    w = 1 / np.pi * .001
+    R = 1.
+
+    dx = 0.15
+    rho = 2.
+
+    interaction = Exponential(w, rho)
+
+    sx = sy = dx * nx
+
+    gtol = 1e-11
+
+    topography = make_sphere(R, (nx, ny), (sx, sy), kind="paraboloid")
+    substrate = Solid.PeriodicFFTElasticHalfSpace((nx, ny), young=Es,
+                                                  physical_sizes=(sx, sy))
+
+    system = BoundedSmoothContactSystem(substrate, interaction, topography)
+
+    penetration = 0.2
+
+    sol = system.minimize_proxy(
+        offset=penetration,
+        options=dict(gtol=gtol, ftol=0),
+        lbounds="auto"
+        )
+
+    assert sol.success
+    print("{}".format(sol.message))
+
+    print("lbfgs nit: {}".format(sol.nit))
+    disp = sol.x
+
+    gap_lbfgs = system.compute_gap(disp, penetration)
+
+    mean_gap = np.sum(gap_lbfgs) / np.prod(substrate.nb_domain_grid_pts)
+
+    forces_lbfgs = - substrate.evaluate_force(disp)
+
+    print("max abs force {}".format(np.max(abs(forces_lbfgs))))
+
+    #  Check that at least the not mean constrained way works
+    init_disp = np.zeros((nx, ny))
+    init_gap = init_disp - topography.heights() - penetration
+    init_gap[init_gap < 0] = 0
+
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap,
+        gtol=gtol,
+        maxiter=1000,
+        )
+
+    assert res.success
+    print("ccg_without_restart nit: {}".format(res.nit))
+    gap = res.x.reshape(substrate.nb_subdomain_grid_pts)
+
+    grad = system.primal_objective(penetration, gradient=True)(
+        gap)[1].reshape(substrate.nb_subdomain_grid_pts)
+
+    assert np.max(abs(grad * (gap > 0))) < gtol
+
+    np.testing.assert_allclose(gap, gap_lbfgs,
+                               atol=1e-6 * abs(topography.min()))
+
+    ##############################
+    # typical initial guess
+
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    _penetration = np.sum(
+        init_disp - topography.heights() - mean_gap) / np.prod(
+        substrate.nb_domain_grid_pts)
+
+    print(_penetration)
+
+    init_gap = init_disp - topography.heights() - _penetration
+    init_gap[init_gap < 0] = 0
+
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol,
+        maxiter=1000,
+        )
+
+    assert res.success
+    print("ccg_without_restart nit: {}".format(res.nit))
+    gap = res.x.reshape(substrate.nb_subdomain_grid_pts)
+
+    np.testing.assert_allclose(gap, gap_lbfgs,
+                               atol=1e-6 * abs(topography.min()))
+
+    grad = system.primal_objective(0, gradient=True)(
+        gap)[1].reshape(substrate.nb_subdomain_grid_pts)
+
+    nc_points = gap > 0
+    nb_nc_points = pnp.sum(np.count_nonzero(nc_points))
+    lagrange_mean_gap = pnp.sum(grad[nc_points]) / nb_nc_points
+
+    forces = - substrate.evaluate_force(gap + topography.heights()) \
+             - lagrange_mean_gap
+
+    np.testing.assert_allclose(forces, forces_lbfgs, atol=10 * gtol)
+
+
+@pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                    reason="tests only serial funcionalities,"
+                           " please execute with pytest")
+def test_mean_value_mode_is_penetration_indepentent():
+    nx, ny = 128, 128
+    # FIXED by the nondimensionalisation
+    # maugis_K = 1.
+    Es = 1  # maugis K = 1.
+    w = .0001
+
+    dx = 1
+    rho = 1
+
+    rms_slope = 0.1
+
+    interaction = Exponential(w, rho)
+
+    sx = sy = dx * nx
+
+    gtol = 1e-11
+    np.random.seed(0)
+    topography = fourier_synthesis(
+        (nx, ny), (sx, sy),
+        0.8,
+        rms_slope=rms_slope,
+        long_cutoff=sx / 2,
+        short_cutoff=4 * dx,
+        )
+    topography ._heights = topography .heights() - np.max(
+        topography .heights())
+    substrate = Solid.PeriodicFFTElasticHalfSpace((nx, ny), young=Es,
+                                                  physical_sizes=(sx, sy))
+
+    system = BoundedSmoothContactSystem(substrate, interaction, topography)
+
+    mean_gap = - np.mean(topography.heights()) - 0.7
+
+    ##############################
+    # typical initial guess
+
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    _penetration = np.sum(
+        init_disp - topography.heights() - mean_gap) / np.prod(
+        substrate.nb_domain_grid_pts)
+
+    print(_penetration)
+
+    init_gap = init_disp - topography.heights() - _penetration
+    init_gap[init_gap < 0] = 0
+
+    ca = []
+    arbitrary_penetration = 0
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(arbitrary_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol,
+        maxiter=1000,
+        callback=lambda x: ca.append(np.count_nonzero(x == 0))
+        )
+    first_ca = ca[0]
+    assert res.success
+
+    ca = []
+    arbitrary_penetration = 100
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(arbitrary_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol,
+        maxiter=1000,
+        callback=lambda x: ca.append(np.count_nonzero(x == 0))
+        )
+    assert ca[0] == first_ca
+    assert res.success
+    print("ccg_without_restart nit: {}".format(res.nit))
+
+    ca = []
+    arbitrary_penetration = -100
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(arbitrary_penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol,
+        maxiter=1000,
+        callback=lambda x: ca.append(np.count_nonzero(x == 0))
+        )
+    assert ca[0] == first_ca
+    assert res.success
+    print("ccg_without_restart nit: {}".format(res.nit))
+
+
+def test_ccg_without_restart_free_system(comm):
+    pnp = Reduction(comm)
+
+    nx, ny = 32, 21
+    sx = sy = 4.
+    R = 4.
+    Es = 0.75
+
+    w = 1 / np.pi * 1e-3
+    rho = 0.05
+
+    # MAKE REFERENCE solution in serial
+
+    surface = make_sphere(R, (nx, ny), (sx, sy),
+                          centre=(sx / 2, sy / 2),
+                          kind="paraboloid", communicator=MPI.COMM_SELF)
+
+    interaction = Exponential(w, rho, communicator=MPI.COMM_SELF)
+
+    substrate = Solid.FreeFFTElasticHalfSpace(
+        (nx, ny), young=Es,
+        physical_sizes=(sx, sy), communicator=MPI.COMM_SELF)
+
+    system = BoundedSmoothContactSystem(substrate, interaction, surface)
+
+    penetration = 0.02
+    lbounds = system._lbounds_from_heights(penetration)
+
+    bnds = system._reshape_bounds(lbounds, )
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+
+    bounded = init_disp < lbounds
+    init_disp[bounded.filled(False)] = lbounds[bounded.filled(False)]
+
+    res = optim.minimize(system.objective(penetration, gradient=True,
+                                          logger=Logger("test_ccg_without_restart_free_system_lbfgsb.log")),
+                         init_disp,
+                         method='L-BFGS-B', jac=True,
+                         bounds=bnds,
+                         options=dict(gtol=1e-11, ftol=1e-20))
+
+    assert res.success
+    _lbfgsb = res.x.reshape((2 * nx, 2 * ny))
+    _lbfgsb_force = - system.substrate.evaluate_force(_lbfgsb)
+    # Parallelized objective
+
+    interaction = Exponential(w, rho, communicator=comm)
+
+    substrate = Solid.FreeFFTElasticHalfSpace((nx, ny), young=Es,
+                                              physical_sizes=(sx, sy),
+                                              communicator=comm,
+                                              fft="mpi")
+
+    surface = make_sphere(
+        R, (nx, ny), (sx, sy),
+        centre=(sx / 2, sy / 2),
+        subdomain_locations=substrate.topography_subdomain_locations,
+        nb_subdomain_grid_pts=substrate.topography_nb_subdomain_grid_pts,
+        kind="paraboloid", communicator=comm)
+
+    system = BoundedSmoothContactSystem(substrate, interaction, surface)
+
+    lbounds_parallel = system._lbounds_from_heights(penetration)
+
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.objective(penetration, gradient=True, logger=Logger("test_ccg_without_restart_free_system_cg.log")),
+        # We also test that the logger and the postprocessing involved work properly in parallel
+        system.hessian_product_function(penetration),
+        init_disp[substrate.subdomain_slices].reshape(-1),
+        gtol=1e-11,
+        bounds=lbounds_parallel.filled().reshape(-1),
+        maxiter=500,
+        communicator=comm
+        )
+    assert res.success
+
+    print(res.nit)
+    _bug = res.x.reshape(substrate.nb_subdomain_grid_pts)
+    _bug_force = - system.substrate.evaluate_force(_bug)
+    if False:
+        import matplotlib.pyplot as plt
+        fig, ax = plt.subplots()
+        ax.plot(_bug[:, ny // 2], label="bug")
+        ax.plot(_lbfgsb[:, ny // 2], label="lbfgsb")
+        ax.legend()
+        # plt.show()
+
+        fig, ax = plt.subplots()
+        ax.plot(system.objective(penetration, gradient=True)(_bug)[1]
+                .reshape((2 * nx, 2 * ny))[:, ny // 2], label="bug")
+        ax.plot(system.objective(penetration, gradient=True)(_lbfgsb)[1]
+                .reshape((2 * nx, 2 * ny))[:, ny // 2], label="lbfgsb")
+
+        ax.plot(_bug_force[:, ny // 2], label="bug")
+        ax.plot(_lbfgsb_force[:, ny // 2], label="lbfgsb")
+
+        ax.legend()
+        plt.show()
+
+    assert pnp.max(abs(_bug - _lbfgsb[substrate.subdomain_slices])) < 1e-5
diff --git a/test/test_ccgs.py b/test/test_ccgs.py
new file mode 100644
index 00000000..9e39bca2
--- /dev/null
+++ b/test/test_ccgs.py
@@ -0,0 +1,98 @@
+from SurfaceTopography import make_sphere
+import ContactMechanics as Solid
+from Adhesion.Interactions import Exponential
+from Adhesion.System import BoundedSmoothContactSystem
+from NuMPI.Optimization import ccg_without_restart, ccg_with_restart
+import numpy as np
+import scipy.optimize as optim
+import pytest
+
+
+@pytest.mark.parametrize("offset", [0, 1.])
+def test_primal_obj(offset):
+    nx, ny = 256, 256
+    # FIXED by the nondimensionalisation
+    # maugis_K = 1.
+    Es = 3 / 4  # maugis K = 1.
+    w = 1 / np.pi
+    R = 1.
+
+    dx = 0.02
+    rho = 0.2
+
+    interaction = Exponential(w, rho)
+
+    sx = sy = dx * nx
+
+    gtol = 1e-5 * abs(interaction.max_tensile) * dx ** 2
+
+    surface = make_sphere(R, (nx, ny), (sx, sy), kind="paraboloid")
+    substrate = Solid.PeriodicFFTElasticHalfSpace((nx, ny), young=Es,
+                                                  physical_sizes=(sx, sy))
+
+    system = BoundedSmoothContactSystem(substrate, interaction, surface)
+
+    lbounds = np.zeros((nx, ny))
+    bnds = system._reshape_bounds(lbounds, )
+
+    init_disp = np.zeros((nx, ny))
+    init_gap = init_disp - surface.heights() - offset
+
+    # ####################POLONSKY-KEER##############################
+    res = ccg_with_restart.constrained_conjugate_gradients(
+        system.primal_objective(offset, gradient=True),
+        system.primal_hessian_product, x0=init_gap, gtol=gtol)
+
+    assert res.success
+    ccg_with_restart_gap = res.x.reshape((nx, ny))
+
+    # ####################BUGNICOURT###################################
+    res = ccg_without_restart.constrained_conjugate_gradients(
+        system.primal_objective(offset, gradient=True),
+        system.primal_hessian_product, x0=init_gap, mean_val=None, gtol=gtol)
+    assert res.success
+
+    ccg_without_restart_gap = res.x.reshape((nx, ny))
+
+    # #####################LBFGSB#####################################
+    res = optim.minimize(system.primal_objective(offset, gradient=True),
+                         init_gap,
+                         method='L-BFGS-B', jac=True,
+                         bounds=bnds,
+                         options=dict(gtol=gtol, ftol=1e-20))
+
+    assert res.success
+    lbfgsb_gap = res.x.reshape((nx, ny))
+
+    np.testing.assert_allclose(ccg_with_restart_gap, ccg_without_restart_gap, atol=1e-3)
+    np.testing.assert_allclose(ccg_with_restart_gap, lbfgsb_gap, atol=1e-3)
+    np.testing.assert_allclose(lbfgsb_gap, ccg_without_restart_gap, atol=1e-3)
+
+    # ##########TEST MEAN VALUES#######################################
+    mean_val = np.mean(lbfgsb_gap)
+    # ####################POLONSKY-KEER##############################
+    res = ccg_with_restart.constrained_conjugate_gradients(
+        system.primal_objective(offset, gradient=True),
+        system.primal_hessian_product, init_gap, gtol=gtol,
+        mean_value=mean_val)
+
+    assert res.success
+    ccg_with_restart_gap_mean_cons = res.x.reshape((nx, ny))
+
+    # ####################BUGNICOURT###################################
+    ccg_without_restart.constrained_conjugate_gradients(system.primal_objective
+                                                        (offset, gradient=True),
+                                                        system.
+                                                        primal_hessian_product,
+                                                        x0=init_gap,
+                                                        mean_val=mean_val,
+                                                        gtol=gtol
+                                                        )
+    assert res.success
+
+    ccg_without_restart_gap_mean_cons = res.x.reshape((nx, ny))
+
+    np.testing.assert_allclose(ccg_with_restart_gap_mean_cons, lbfgsb_gap, atol=1e-3)
+    np.testing.assert_allclose(ccg_without_restart_gap_mean_cons, lbfgsb_gap, atol=1e-3)
+    np.testing.assert_allclose(lbfgsb_gap, ccg_without_restart_gap, atol=1e-3)
+    np.testing.assert_allclose(lbfgsb_gap, ccg_without_restart_gap_mean_cons, atol=1e-3)
diff --git a/test/test_halfcomplex_objective.py b/test/test_halfcomplex_objective.py
new file mode 100644
index 00000000..488b1667
--- /dev/null
+++ b/test/test_halfcomplex_objective.py
@@ -0,0 +1,264 @@
+import numpy as np
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from SurfaceTopography import Topography
+from Adhesion.Interactions import RepulsiveExponential
+from Adhesion.System import SmoothContactSystem, make_system
+import muFFT
+from SurfaceTopography.Generation import fourier_synthesis
+import pytest
+from NuMPI import MPI
+
+pytestmark = pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                                reason="tests only serial funcionalities, "
+                                       "please execute with pytest")
+
+
+def test_2d():
+    n = 32
+    surf_res = (n, n)
+
+    z0 = 1
+    Es = 1
+    w = 0.01 * z0 * Es
+    surf_size = (n, n)
+
+    inter = RepulsiveExponential(2 * w, 0.5, w, 1.)
+
+    substrate = PeriodicFFTElasticHalfSpace(surf_res, young=Es,
+                                            physical_sizes=surf_size)
+
+    surface = Topography(
+        np.cos(np.arange(0, n) * np.pi * 2. / n) * np.ones((n, 1)),
+        physical_sizes=surf_size)
+
+    system = SmoothContactSystem(substrate, inter, surface)
+
+    penetrations = np.linspace(-np.max(surface.heights()), 0, 10)
+
+    # disp0 = np.zeros(surface.nb_grid_pts)
+    # init_gap = disp0 - system.surface.heights() - penetrations[5]
+    # init_gap[init_gap < 0] = 0
+    # disp0 = init_gap + system.surface.heights() + penetrations[5]
+
+    disp0 = np.random.uniform(0, 1, size=surface.nb_grid_pts)
+
+    engine = muFFT.FFT(substrate.nb_grid_pts, fft='fftw',
+                       allow_temporary_buffer=False,
+                       allow_destroy_input=True)
+
+    real_buffer = engine.register_halfcomplex_field(
+        "real-space", 1)
+    fourier_buffer = engine.register_halfcomplex_field(
+        "fourier-space", 1)
+
+    real_buffer.array()[...] = disp0.copy()
+    engine.hcfft(real_buffer, fourier_buffer)
+    k_float_disp = fourier_buffer.array()[...].copy()
+    k_float_disp_mw = k_float_disp * np.sqrt(
+        system.stiffness_k)
+
+    en_mw = system.preconditioned_objective(penetrations[5], gradient=True)(
+        k_float_disp_mw)[0]
+    # print('mw el {}'.format(system.substrate.energy))
+    en_mw_el = system.substrate.energy
+    en_mw_adh = system.interaction_energy
+    en_real = system.objective(penetrations[5], gradient=True)(disp0)[0]
+    en_real_el = system.substrate.energy
+    en_real_adh = system.interaction_energy
+    # print('real el {} '.format(system.substrate.energy))
+    en_fourier = \
+        system.objective_k_float(penetrations[5], gradient=True)(k_float_disp)[
+            0]
+    en_fourier_el = system.substrate.energy
+    en_fourier_adh = system.interaction_energy
+    # print('fourier el {} '.format(system.substrate.energy))
+
+    # print(en_fourier, en_real, en_mw)
+
+    np.testing.assert_allclose(en_mw_el, en_real_el, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_el, en_real_el, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_el, en_mw_el, atol=1e-8)
+    np.testing.assert_allclose(en_mw_adh, en_real_adh, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_adh, en_real_adh, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_adh, en_mw_adh, atol=1e-8)
+    np.testing.assert_allclose(en_mw, en_real, atol=1e-8)
+    np.testing.assert_allclose(en_fourier, en_real, atol=1e-8)
+    np.testing.assert_allclose(en_fourier, en_mw, atol=1e-8)
+
+
+def test_1d():
+    Es = 1.
+    # rms_slope = 1.
+    dx = 1
+    n = 1024
+    s = n * dx
+
+    short_cutoff = 0.01 * s
+
+    topo = fourier_synthesis(nb_grid_pts=(n,),
+                             hurst=0.8,  # Fig. 4
+                             physical_sizes=(s,),
+                             rms_slope=1.,
+                             long_cutoff=s,  # Fig. 4
+                             short_cutoff=short_cutoff,
+                             )
+
+    Rc = 1 / topo.rms_curvature_from_profile()
+    interaction_length = 2.56e-2 * Rc
+
+    gam_att = 2.05 * Es * Rc
+    gam_rep = 2.10e3 * Es * Rc
+
+    interaction = RepulsiveExponential(gam_rep, interaction_length / 2,
+                                       gam_att,
+                                       interaction_length).linearize_core(
+        hardness=1000 * Es * topo.rms_slope_from_profile())
+
+    # w = abs(interaction.v_min)
+
+    system = make_system(interaction=interaction,
+                         surface=topo,
+                         substrate="periodic",
+                         young=Es,
+                         system_class=SmoothContactSystem)
+    substrate = system.substrate
+
+    engine = muFFT.FFT(substrate.nb_grid_pts, fft='fftw',
+                       allow_temporary_buffer=False,
+                       allow_destroy_input=True)
+
+    real_buffer = engine.register_halfcomplex_field(
+        "real-space", 1)
+    fourier_buffer = engine.register_halfcomplex_field(
+        "fourier-space", 1)
+
+    penetrations = np.linspace(-np.max(topo.heights()), 0, 10)
+
+    disp0 = np.zeros(topo.nb_grid_pts)
+    init_gap = disp0 - system.surface.heights() - penetrations[5]
+    disp0 = init_gap
+    # init_gap[init_gap < 0] = 0
+    # disp0 = init_gap + system.surface.heights() + penetrations[5]
+
+    real_buffer.array()[...] = disp0.copy()
+    engine.hcfft(real_buffer, fourier_buffer)
+    k_float_disp = fourier_buffer.array()[...].copy()
+    k_float_disp_mw = k_float_disp * np.sqrt(
+        system.stiffness_k)
+
+    en_mw = system.preconditioned_objective(penetrations[5], gradient=True)(
+        k_float_disp_mw)[0]
+    en_mw_el = system.substrate.energy
+    en_mw_adh = system.interaction_energy
+    en_real = system.objective(penetrations[5], gradient=True)(disp0)[0]
+    en_real_el = system.substrate.energy
+    en_real_adh = system.interaction_energy
+    en_fourier = \
+        system.objective_k_float(penetrations[5], gradient=True)(k_float_disp)[
+            0]
+    en_fourier_el = system.substrate.energy
+    en_fourier_adh = system.interaction_energy
+
+    # print(en_fourier, en_real, en_mw, en_real_el, en_fourier_el, en_mw_el)
+
+    np.testing.assert_allclose(en_mw, en_real, atol=1e-8)
+    np.testing.assert_allclose(en_fourier, en_real, atol=1e-8)
+    np.testing.assert_allclose(en_fourier, en_mw, atol=1e-8)
+    np.testing.assert_allclose(en_mw_el, en_real_el, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_el, en_real_el, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_el, en_mw_el, atol=1e-8)
+    np.testing.assert_allclose(en_mw_adh, en_real_adh, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_adh, en_real_adh, atol=1e-8)
+    np.testing.assert_allclose(en_fourier_adh, en_mw_adh, atol=1e-8)
+
+
+@pytest.mark.skip("preconditioned hessian (product) not implemented yet. See issue #49")
+def test_preconditioned_hessian():
+    n = 32
+    surf_res = (n, n)
+
+    z0 = 1
+    Es = 1
+    w = 0.01 * z0 * Es
+    surf_size = (n, n)
+
+    inter = RepulsiveExponential(2 * w, 0.5, w, 1.)
+
+    substrate = PeriodicFFTElasticHalfSpace(surf_res, young=Es,
+                                            physical_sizes=surf_size)
+
+    surface = Topography(
+        np.cos(np.arange(0, n) * np.pi * 2. / n) * np.ones((n, 1)),
+        physical_sizes=surf_size)
+
+    system = SmoothContactSystem(substrate, inter, surface)
+
+    # penetrations = np.linspace(-np.max(surface.heights()), 0, 10)
+    offset = 0  # penetrations[5]
+
+    engine = muFFT.FFT(substrate.nb_grid_pts, fft='fftw',
+                       allow_temporary_buffer=False,
+                       allow_destroy_input=True)
+
+    real_buffer = engine.register_halfcomplex_field(
+        "real-space", 1)
+    fourier_buffer = engine.register_halfcomplex_field(
+        "fourier-space", 1)
+
+    obj = system.preconditioned_objective(offset, True)
+
+    gaps = np.random.uniform(0, 1, size=surface.nb_grid_pts)
+    # np.random.random(size=(n, n))
+    real_buffer.array()[...] = gaps.copy()
+    engine.hcfft(real_buffer, fourier_buffer)
+    k_float_disp = fourier_buffer.array()[...].copy()
+
+    dgaps = np.random.normal(size=(n, n)) * np.mean(gaps) / 10
+    real_buffer.array()[...] = dgaps.copy()
+    engine.hcfft(real_buffer, fourier_buffer)
+    d_k_float_disp = fourier_buffer.array()[...].copy()
+
+    _, grad = obj(k_float_disp)
+
+    if True:
+        hs = np.array([1, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5,
+                       1e-6, 1e-7])
+        rms_errors = []
+        for h in hs:
+            _, grad_d = obj(k_float_disp + h * d_k_float_disp)
+            dgrad = grad_d - grad
+            # dgrad_from_hess = cf.hessian_product(h * da, a, penetration)
+            dgrad_from_hess = system.hessian_product_preconditioned(offset)(
+                k_float_disp, h * d_k_float_disp)
+
+            rms_errors.append(np.sqrt(np.mean((dgrad_from_hess - dgrad) ** 2)))
+
+        # Visualize the quadratic convergence of the taylor expansion
+        # What to expect:
+        # Taylor expansion: g(x + h ∆x) - g(x) = Hessian * h * ∆x + O(h^2)
+        # We should see quadratic convergence as long as h^2 > g epsmach,
+        # the precision with which we are able to determine ∆g.
+        # What is the precision with which the hessian product is made ?
+        import matplotlib.pyplot as plt
+        fig, ax = plt.subplots()
+        ax.plot(hs, rms_errors / hs ** 2, "+-")
+        ax.set_xscale("log")
+        ax.set_yscale("log")
+        ax.grid(True)
+        plt.show()
+
+        hs = np.array([1e-2, 1e-3, 1e-4])
+    rms_errors = []
+    for h in hs:
+        grad_d = obj(k_float_disp + h * d_k_float_disp)[1]
+        dgrad = grad_d - grad
+        dgrad_from_hess = system.hessian_product_preconditioned(offset)(
+            k_float_disp, h * d_k_float_disp)
+        rms_errors.append(np.sqrt(np.mean((dgrad_from_hess - dgrad) ** 2)))
+        rms_errors.append(
+            np.sqrt(
+                np.mean(
+                    (dgrad_from_hess.reshape(-1) - dgrad.reshape(-1)) ** 2)))
+
+    rms_errors = np.array(rms_errors)
+    assert rms_errors[-1] / rms_errors[0] < 1.5 * (hs[-1] / hs[0]) ** 2
diff --git a/test/test_halfcomplexfft_elasticity.py b/test/test_halfcomplexfft_elasticity.py
new file mode 100644
index 00000000..62b30ba9
--- /dev/null
+++ b/test/test_halfcomplexfft_elasticity.py
@@ -0,0 +1,116 @@
+import numpy as np
+import pytest
+from muFFT import FFT
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from SurfaceTopography.Generation import fourier_synthesis
+from Adhesion.Interactions import RepulsiveExponential
+from Adhesion.System import make_system, SmoothContactSystem
+from NuMPI import MPI
+
+pytestmark = pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                                reason="tests only serial funcionalities, "
+                                       "please execute with pytest")
+
+
+@pytest.mark.parametrize("nx, ny", [(15, 15),
+                                    (8, 8),
+                                    (9, 9),
+                                    (113, 113)])
+@pytest.mark.parametrize("k", [(1, 0),
+                               (0, 1),
+                               (1, 2),
+                               (4, 0),
+                               (1, 4),
+                               (0, 2),
+                               (4, 4),
+                               (0, 4)])
+def test_sinewave_(k, nx, ny):
+    """
+    for given sinusoidal displacements, compares the energies
+    to the analytical solutions
+
+    Special cases at the edges of the fourier domain are done
+
+    Parameters
+    ----------
+    k
+
+    Returns
+    -------
+
+    """
+
+    sx = 2.45  # 30.0
+    sy = 1.0
+
+    # equivalent Young's modulus
+    E_s = 1.0
+
+    qx = k[0] * np.pi * 2 / sx
+    qy = k[1] * np.pi * 2 / sy
+    q = np.sqrt(qx ** 2 + qy ** 2)
+
+    ###########################################################
+    # This is only for the purpose of using the mass-weighted objective
+    # accessible only through the Adhesive system. Interaction and Topography
+    # do not affect the computation of mw_energy.
+
+    topo = fourier_synthesis(nb_grid_pts=(nx, ny),
+                             hurst=0.8,  # Fig. 4
+                             physical_sizes=(sx, sy),
+                             rms_slope=1.,
+                             long_cutoff=sx,
+                             short_cutoff=0.01 * sx,
+                             )
+
+    inter = RepulsiveExponential(0, 0.5, 0, 1.0)
+
+    system = make_system(interaction=inter,
+                         surface=topo,
+                         substrate="periodic",
+                         young=1.0,
+                         system_class=SmoothContactSystem)
+    ################################################################
+
+    Y, X = np.meshgrid(np.linspace(0, sy, ny + 1)[:-1],
+                       np.linspace(0, sx, nx + 1)[:-1])
+    disp = np.cos(qx * X + qy * Y) + np.sin(qx * X + qy * Y)
+
+    substrate = PeriodicFFTElasticHalfSpace((nx, ny), E_s, (sx, sy),
+                                            fft='fftw')
+    engine = FFT((nx, ny), fft='fftw')
+
+    real_buffer = engine.register_halfcomplex_field(
+        "real-space", 1)
+    fourier_buffer = engine.register_halfcomplex_field(
+        "fourier-space", 1)
+    real_buffer.array()[...] = disp.copy()
+    engine.hcfft(real_buffer, fourier_buffer)
+    k_float_disp = fourier_buffer.array()[...].copy()
+    k_float_disp_mw = k_float_disp * np.sqrt(system.stiffness_k)
+
+    engine.create_plan(1)
+
+    expected_k_disp = np.zeros((nx, ny), dtype=complex)
+    expected_k_disp[k[0], k[1]] += (.5 - .5j) * (nx * ny)
+
+    mw_energy = \
+        system.preconditioned_objective(0, gradient=True)(k_float_disp_mw)[0]
+
+    fourier_energy = system.objective_k_float(0., gradient=True)(k_float_disp)[0]
+
+    refenergy = E_s / 8 * 2 * q * sx * sy
+
+    np.testing.assert_allclose(
+        mw_energy, refenergy, rtol=1e-10,
+        err_msg=f"wavevektor {k} for "
+                f"nb_domain_grid_pts {substrate.nb_domain_grid_pts},"
+                f" subdomain nb_grid_pts {substrate.nb_subdomain_grid_pts}, "
+                f"nb_fourier_grid_pts {substrate.nb_fourier_grid_pts}")
+
+    np.testing.assert_allclose(
+        fourier_energy, refenergy, rtol=1e-10,
+        err_msg=f"wavevektor {k} for "
+                f"nb_domain_grid_pts {substrate.nb_domain_grid_pts},"
+                f" subdomain nb_grid_pts {substrate.nb_subdomain_grid_pts}, "
+                f"nb_fourier_grid_pts {substrate.nb_fourier_grid_pts}")
diff --git a/test/test_rough_weakly_adhesive.py b/test/test_rough_weakly_adhesive.py
new file mode 100644
index 00000000..3a2141d5
--- /dev/null
+++ b/test/test_rough_weakly_adhesive.py
@@ -0,0 +1,183 @@
+from SurfaceTopography import Topography
+from SurfaceTopography.Generation import fourier_synthesis
+from Adhesion.Interactions import Exponential
+from ContactMechanics.Systems import NonSmoothContactSystem
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from Adhesion.System import make_system, BoundedSmoothContactSystem
+from NuMPI.Optimization.ccg_without_restart import constrained_conjugate_gradients
+# from NuMPI import MPI
+from NuMPI.Tools import Reduction
+import pytest
+from NuMPI import MPI
+
+import numpy as np
+
+pytestmark = pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                                reason="tests only serial funcionalities, "
+                                       "please execute with pytest")
+
+
+def test_ccg_without_restart_weakly_adhesive(comm, verbose=False):
+    Es = 1.
+    gtol = 1e-8
+    n = 512
+    dx = 1.
+    s = n
+
+    hprms = 0.1
+
+    np.random.seed(0)
+    full_topography = fourier_synthesis((n, n), (s, s), 0.8, rms_slope=hprms,
+                                        long_cutoff=s / 2, short_cutoff=32, )
+
+    full_topography._heights = full_topography.heights() - np.max(full_topography.heights())
+
+    pnp = Reduction(comm)
+
+    # interaction parameters
+    elastocapillary_length = 0.005 * dx
+    w = Es * elastocapillary_length
+    # Interaction range as in P&R PNAS
+    # with some modifications
+    rho = dx / 4
+    # P&R keep the interaction parameters and vary h'rms,
+    # We keep h'rms constant and hence need to vary the interaction parameters
+    # accordingly
+
+    interaction = Exponential(w, rho)
+
+    substrate = PeriodicFFTElasticHalfSpace(
+        nb_grid_pts=(n, n),
+        physical_sizes=(n, n),
+        young=Es,
+        fft="mpi",
+        communicator=comm)
+
+    topography = Topography(
+        full_topography.heights(),
+        physical_sizes=(n, n),
+        decomposition="domain",
+        nb_subdomain_grid_pts=substrate.nb_subdomain_grid_pts,
+        subdomain_locations=substrate.subdomain_locations,
+        communicator=comm,)
+
+    system = make_system(interaction=interaction, surface=topography,
+                         substrate=substrate,
+                         system_class=BoundedSmoothContactSystem,
+                         communicator=comm)
+    substrate = system.substrate
+
+    if verbose:
+        print('Some informations on the system')
+
+        process_zone_size = Es * w / np.pi / abs(interaction.max_tensile) ** 2
+
+        print("nb pixels in process zone: {}".format(process_zone_size / dx))
+        # print("highcut wavelength / process_zone size: "
+        #       "{}".format(short_cutoff / process_zone_size))
+        print("rms_height / interaction_length: "
+              "{}".format(topography.rms_height() / rho))
+
+        print("Persson and Tosatti adhesion criterion: ")
+        print("elastic deformation energy for full contact / work of "
+              "adhesion: {}".format(substrate.evaluate(
+                topography.detrend().heights())[0] / w / np.prod(
+                topography.physical_sizes)))  # ^
+        #            sets the mean to zero, so         |
+        #            that the energy of the q = 0   --
+        #            mode is not taken into
+        #            account
+
+        # P&R equation 10, with kappa_rep = 2, d_rep=4 h'rms / h''rms
+        # (Only valid in the DMT regime, i.e. until the onset of stickiness)
+        # If this value is smaller then 1 the surfaces are sticky and
+        # normal CG's might not work anymore
+        print("P&R stickiness criterion: {}".format(topography.rms_gradient() *
+                                                    Es * rho / 2 / w *
+              (topography.rms_gradient() ** 2 / topography.rms_curvature() / rho)
+                                                    ** (2 / 3)))
+        R = 1 / topography.rms_curvature()
+        print("Generalized Tabor parameter à la Martin Müser")
+        print("{}".format(R**(1/3) * elastocapillary_length ** (2 / 3) / rho))
+
+    print(""" ########## PENETRATION CONTROLLED ################## """)
+
+    penetration = 0.1
+
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    init_gap = init_disp - topography.heights() - penetration
+    init_gap[init_gap < 0] = 0
+
+    res = constrained_conjugate_gradients(
+        system.primal_objective(penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=None,
+        gtol=gtol * max(Es * hprms, abs(
+                interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000)
+
+    print(res.nit)
+
+    assert res.success, res.message
+    gap = res.x
+
+    print(""" ########## mean_gap controlled ################# """)
+
+    mean_gap = pnp.sum(gap) / np.prod(substrate.nb_domain_grid_pts)
+
+    # typical initial guess
+    init_disp = np.zeros(substrate.nb_subdomain_grid_pts)
+    penetration = pnp.sum(init_disp - topography.heights() - mean_gap) / \
+        np.prod(substrate.nb_domain_grid_pts)
+
+    print(penetration)
+
+    init_gap = init_disp - topography.heights() - penetration
+    init_gap[init_gap < 0] = 0
+
+    res = constrained_conjugate_gradients(
+        system.primal_objective(penetration, gradient=True),
+        system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol * max(Es * hprms, abs(
+                interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000)
+
+    assert res.success, res.message
+    gap = res.x
+    print(res.nit)
+
+    print(""" #########   NONADHESIVE, same mean gap ############# """)
+    nonadh_system = NonSmoothContactSystem(substrate=substrate,
+                                           surface=topography)
+
+    res = constrained_conjugate_gradients(
+        nonadh_system.primal_objective(penetration, gradient=True),
+        nonadh_system.primal_hessian_product,
+        x0=init_gap, mean_val=mean_gap,
+        gtol=gtol * max(Es * hprms, abs(
+                interaction.max_tensile)) * topography.area_per_pt,
+        maxiter=1000)
+
+    assert res.success, res.message
+    gap_nonadh = res.x
+    print(res.nit)
+
+    if verbose and comm.Get_size() == 1.:
+        import matplotlib.pyplot as plt
+        from matplotlib.colors import LinearSegmentedColormap
+
+        fig, ax = plt.subplots()
+
+        contactcmap = LinearSegmentedColormap.from_list('contactcmap',
+                                                        ((1, 1, 1, 0.),
+                                                         (1, 0, 0, 1)),
+                                                        N=256)
+        ax.imshow(gap.reshape(substrate.nb_grid_pts) == 0, cmap=contactcmap)
+
+        contactcmap = LinearSegmentedColormap.from_list('contactcmap',
+                                                        ((1, 1, 1, 0.),
+                                                         (0, 1, 0, 1)),
+                                                        N=256)
+        ax.imshow(gap_nonadh.reshape(substrate.nb_grid_pts) == 0,
+                  cmap=contactcmap)
diff --git a/test/test_system.py b/test/test_system.py
index af6f8a18..9d157494 100644
--- a/test/test_system.py
+++ b/test/test_system.py
@@ -40,7 +40,8 @@
 from ContactMechanics.Systems import IncompatibleResolutionError
 from Adhesion.System import SmoothContactSystem
 import ContactMechanics as Solid
-import Adhesion.Interactions as Contact
+import Adhesion.Interactions as Inter
+
 import ContactMechanics.Tools as Tools
 from SurfaceTopography import make_sphere, Topography
 
@@ -70,12 +71,11 @@ def self(request):
     self.sig = 3 + np.random.rand()
     self.gam = (5 + np.random.rand())
     self.rcut = 2.5 * self.sig + np.random.rand()
-    self.smooth = Contact.LJ93(self.eps, self.sig
-                               ).spline_cutoff(self.gam
-                                               ).linearize_core()
+    self.smooth = Inter.LJ93(self.eps, self.sig
+                             ).spline_cutoff(self.gam
+                                             ).linearize_core()
 
-    self.sphere = make_sphere(self.radius, self.res,
-                              self.physical_sizes)
+    self.sphere = make_sphere(self.radius, self.res, self.physical_sizes)
     return self
 
 
@@ -334,7 +334,7 @@ def test_LBFGSB_Hertz():
                                               fft="serial",
                                               communicator=MPI.COMM_SELF)
 
-    interaction = Contact.Exponential(0., 0.0001)
+    interaction = Inter.Exponential(0., 0.0001)
     system = SmoothContactSystem(substrate, interaction, surface)
 
     gtol = 1e-6
@@ -398,8 +398,75 @@ def test_undefined_data():
                   [False, False, False]]
             ), (2, 3))
 
-    interaction = Contact.Lj82(1., 1.)
+    interaction = Inter.Lj82(1., 1.)
     substrate = Solid.PeriodicFFTElasticHalfSpace((2, 3), 1, (2, 3))
     with pytest.raises(ValueError):
         SmoothContactSystem(interaction=interaction,
                             substrate=substrate, surface=t)
+
+
+@pytest.mark.parametrize("s", (1., 2.))
+def test_primal_hessian_product(s):
+    nx = 64
+    ny = 32
+
+    sx = sy = s
+    R = 10.
+    Es = 50.
+
+    interaction = Inter.RepulsiveExponential(1000, 0.5, 1., 1.)
+
+    substrate = Solid.PeriodicFFTElasticHalfSpace((nx, ny), young=Es,
+                                                  physical_sizes=(sx, sy))
+
+    topography = make_sphere(R, (nx, ny), (sx, sy), kind="paraboloid")
+
+    system = SmoothContactSystem(substrate=substrate, surface=topography,
+                                 interaction=interaction)
+
+    obj = system.primal_objective(0, True, True)
+
+    gaps = interaction.r_min * (0.8 + np.random.random(size=(nx, ny)))
+    dgaps = interaction.r_min * (0.5 + np.random.random(size=(nx, ny)))
+
+    _, grad = obj(gaps)
+
+    hs = np.array([1e-2, 1e-3, 1e-4])
+    rms_errors = []
+    for h in hs:
+        _, grad_d = obj(gaps + h * dgaps)
+        dgrad = grad_d - grad
+        dgrad_from_hess = system.primal_hessian_product(gaps, h * dgaps)
+        rms_errors.append(
+            np.sqrt(
+                np.mean(
+                    (dgrad_from_hess.reshape(-1) - dgrad.reshape(-1)) ** 2)))
+
+    rms_errors = np.array(rms_errors)
+    assert rms_errors[-1] / rms_errors[0] < 1.5 * (hs[-1] / hs[0]) ** 2
+
+    if False:
+        hs = np.array([1, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5,
+                       1e-6, 1e-7])
+        rms_errors = []
+        for h in hs:
+            _, grad_d = obj(gaps + h * dgaps)
+            dgrad = grad_d - grad
+            dgrad_from_hess = system.primal_hessian_product(gaps, h * dgaps)
+            rms_errors.append(np.sqrt(np.mean((dgrad_from_hess - dgrad) ** 2)))
+
+        # Visualize the quadratic convergence of the taylor expansion
+        # What to expect:
+        # Taylor expansion: g(x + h ∆x) - g(x) = Hessian * h * ∆x + O(h^2)
+        # We should see quadratic convergence as long as h^2 > g epsmach,
+        # the precision with which we are able to determine ∆g.
+        # What is the precision with which the hessian product is made ?
+        import matplotlib.pyplot as plt
+        fig, ax = plt.subplots()
+        ax.plot(hs, rms_errors / hs ** 2, "+-")
+        ax.set_xscale("log")
+        ax.set_yscale("log")
+        ax.grid(True)
+        plt.show()
+
+    # np.testing.assert_allclose(dgrad_from_hess, dgrad)
diff --git a/test/test_wavy_adhesive.py b/test/test_wavy_adhesive.py
new file mode 100644
index 00000000..b8cc49d8
--- /dev/null
+++ b/test/test_wavy_adhesive.py
@@ -0,0 +1,148 @@
+import pytest
+from NuMPI import MPI
+import numpy as np
+from ContactMechanics import PeriodicFFTElasticHalfSpace
+from SurfaceTopography import UniformLineScan
+
+from Adhesion.Interactions import VDW82, Exponential
+from Adhesion.System import SmoothContactSystem, BoundedSmoothContactSystem
+from Adhesion.ReferenceSolutions.sinewave import JKR
+
+pytestmark = pytest.mark.skipif(MPI.COMM_WORLD.Get_size() > 1,
+                                reason="tests only serial funcionalities,"
+                                       " please execute with pytest")
+
+
+def test_1d_sinewave_smooth_against_jkr():
+    s = 1.
+
+    Es = 1. / np.pi
+    alpha = 0.2  # nondimensionalized stress intensity factor
+    w = alpha ** 2 / (2 * Es)
+    abserror = []
+    for p in [8, 10]:
+        n = 2 ** p
+        dx = s / n
+        z0 = 2 * np.sqrt(dx)
+
+        inter = VDW82(w * z0 ** 8 / 3, 16 * np.pi * w * z0 ** 2
+                      ).spline_cutoff(gamma=w
+                                      ).linearize_core()
+
+        substrate = PeriodicFFTElasticHalfSpace((n,), young=Es,
+                                                physical_sizes=(s,),
+                                                fft='serial')
+
+        surface = UniformLineScan(
+            np.cos(np.arange(0, n) * np.pi * 2. / n),
+            physical_sizes=(s,))
+
+        system = SmoothContactSystem(substrate, inter, surface)
+
+        offsets = np.linspace(-2, 0.35, 20)
+        offsets = np.concatenate((offsets, offsets[-2::-1]))
+
+        contact_areas = np.zeros_like(offsets)
+        mean_pressures = np.zeros_like(offsets)
+
+        disp0 = None
+        gtol = 1e-5
+
+        i = 0
+        for offset in offsets:
+            if disp0 is not None:
+                disp0 += offset - offset_prev  # noqa: F821
+            sol = system.minimize_proxy(
+                initial_displacements=disp0,
+                options=dict(
+                    gtol=gtol * max(Es * surface.rms_slope_from_profile(),
+                                    abs(inter.max_tensile))
+                    * surface.area_per_pt,
+                    # max absolute value of the gradient
+                    # of the objective for convergence
+                    ),
+                # logger=Logger("laststep.log"),
+                method="L-BFGS-B",
+                offset=offsets[i],
+                callback=None,
+                lbounds="auto"
+                )
+            assert sol.success, sol.message
+            disp0 = sol.x
+            mean_pressures[i] = system.compute_normal_force() / s
+            contact_areas[i] = np.count_nonzero(system.gap < inter.r_infl) / n
+
+            offset_prev = offset  # noqa: F841
+            i += 1
+
+        abserror.append(np.max(abs(
+            mean_pressures - JKR.mean_pressure(contact_areas / 2, alpha))))
+
+    assert abserror[-1] < abserror[0]
+    assert abserror[-1] < 1e-2
+
+
+def test_1d_sinewave_hardwall_against_jkr():
+    s = 1.
+
+    Es = 1. / np.pi
+    alpha = 0.2  # nondimensionalized stress intensity factor
+    w = alpha ** 2 / (2 * Es)  # = alpha^2 np.pi / 2
+    abserror = []
+    for p in [8, 10]:
+        n = 2 ** p
+        dx = s / n
+        rho = np.sqrt(dx)
+
+        inter = Exponential(w, rho)
+
+        substrate = PeriodicFFTElasticHalfSpace((n,), young=Es,
+                                                physical_sizes=(s,),
+                                                fft='serial')
+
+        surface = UniformLineScan(
+            np.cos(np.arange(0, n) * np.pi * 2. / n),
+            physical_sizes=(s,), periodic=True)
+
+        system = BoundedSmoothContactSystem(substrate, inter, surface)
+
+        offsets = np.linspace(-2, 0.35, 20)
+        offsets = np.concatenate((offsets, offsets[-2::-1]))
+
+        contact_areas = np.zeros_like(offsets)
+        mean_pressures = np.zeros_like(offsets)
+
+        disp0 = None
+        gtol = 1e-5
+        i = 0
+        for offset in offsets:
+            if disp0 is not None:
+                disp0 += offset - offset_prev  # noqa: F821
+            sol = system.minimize_proxy(
+                initial_displacements=disp0,
+                options=dict(gtol=gtol * max(Es * surface.rms_slope_from_profile(),
+                                             abs(inter.max_tensile))
+                             * surface.area_per_pt,
+                             # max absolute value of the gradient
+                             # of the objective for convergence
+                             ),
+                # logger=Logger("laststep.log"),
+                method="L-BFGS-B",
+                offset=offset,
+                callback=None,
+                lbounds="auto"
+                )
+            assert sol.success, sol.message
+            disp0 = sol.x
+            mean_pressures[i] = system.compute_normal_force() / s
+            contact_areas[i] = system.compute_contact_area() / s
+
+            # print("step {}".format(i))
+            offset_prev = offset  # noqa: F841
+            i += 1
+
+        abserror.append(np.max(abs(
+            mean_pressures - JKR.mean_pressure(contact_areas / 2, alpha))))
+
+    assert abserror[-1] < abserror[0]
+    assert abserror[-1] < 1e-2