diff --git a/INFOS.py b/INFOS.py
index 0b9b760..28ba298 100755
--- a/INFOS.py
+++ b/INFOS.py
@@ -1,54 +1,55 @@
 #!/usr/bin/env python3
 
 """Defines the information to be used throughout the builds."""
 
 # -*- mode:python; coding: utf-8 -*-
 
 from collections import namedtuple
 import versioneer
 
 TamaasInfo = namedtuple('TamaasInfo',
                         ['version',
                          'authors',
                          'maintainer',
                          'email',
                          'copyright',
                          'description',
                          'license'])
 
 TAMAAS_INFOS = TamaasInfo(
     version=versioneer.get_version(),
     authors=([
         u'Lucas Frérot',
         'Guillaume Anciaux',
         'Valentine Rey',
         'Son Pham-Ba',
         u'Jean-François Molinari'
     ]),
     maintainer=u'Lucas Frérot',
     email='lucas.frerot@imtek.uni-freiburg.de',
     copyright=(
-        u"Copyright (©) 2016-2022 EPFL "
-        u"(École Polytechnique Fédérale de Lausanne), "
-        u"Laboratory (LSMS - Laboratoire de Simulation en "
-        u"Mécanique des Solides)"
+        "Copyright (©) 2016-2020 EPFL "
+        "(École Polytechnique Fédérale de Lausanne), "
+        "Laboratory (LSMS - Laboratoire de Simulation en "
+        "Mécanique des Solides)\\n"
+        "Copyright (©) 2020-2022 Lucas Frérot"
     ),
     description='A high-performance library for periodic rough surface contact',
     license="SPDX-License-Identifier: AGPL-3.0-or-later",
 )
 
 
 def main():
     import argparse
 
     parser = argparse.ArgumentParser(description="Print Tamaas info")
     parser.add_argument("--version", action="store_true")
 
     args = parser.parse_args()
 
     if args.version:
         print(TAMAAS_INFOS.version)
 
 
 if __name__ == "__main__":
     main()
diff --git a/python/cast.hh b/python/cast.hh
index e5cc85c..f99534c 100644
--- a/python/cast.hh
+++ b/python/cast.hh
@@ -1,196 +1,197 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef CAST_HH
 #define CAST_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_base.hh"
 #include "numpy.hh"
 /* -------------------------------------------------------------------------- */
 #include <boost/preprocessor/seq.hpp>
 #include <pybind11/cast.h>
 /* -------------------------------------------------------------------------- */
 
 namespace pybind11 {
 
 // Format descriptor necessary for correct wrap of tamaas complex type
 template <typename T>
 struct format_descriptor<
     tamaas::complex<T>, detail::enable_if_t<std::is_floating_point<T>::value>> {
   static constexpr const char c = format_descriptor<T>::c;
   static constexpr const char value[3] = {'Z', c, '\0'};
   static std::string format() { return std::string(value); }
 };
 
 #ifndef PYBIND11_CPP17
 
 template <typename T>
 constexpr const char format_descriptor<
     tamaas::complex<T>,
     detail::enable_if_t<std::is_floating_point<T>::value>>::value[3];
 
 #endif
 
 namespace detail {
 
 // declare tamaas complex as a complex type for pybind11
 template <typename T>
 struct is_complex<tamaas::complex<T>> : std::true_type {};
 
 template <typename T>
 struct is_fmt_numeric<tamaas::complex<T>,
                       detail::enable_if_t<std::is_floating_point<T>::value>>
     : std::true_type {
   static constexpr int index = is_fmt_numeric<T>::index + 3;
 };
 
 static inline handle policy_switch(return_value_policy policy, handle parent) {
   switch (policy) {
   case return_value_policy::copy:
   case return_value_policy::move:
     return handle();
   case return_value_policy::automatic_reference:  // happens in python-derived
                                                   // classes
   case return_value_policy::reference:
     return none();
   case return_value_policy::reference_internal:
     return parent;
   default:
     TAMAAS_EXCEPTION("Policy is not handled");
   }
 }
 
 template <class array, typename T, tamaas::UInt dim>
 handle grid_to_python(const tamaas::Grid<T, dim>& grid,
                       return_value_policy policy, handle parent) {
   parent = policy_switch(policy, parent);  // reusing variable
   std::vector<tamaas::UInt> sizes(dim);
   std::copy(grid.sizes().begin(), grid.sizes().end(), sizes.begin());
 
   if (grid.getNbComponents() != 1)
     sizes.push_back(grid.getNbComponents());
 
   return array(sizes, grid.getInternalData(), parent).release();
 }
 
 template <class array, typename T>
 handle grid_to_python(const tamaas::GridBase<T>& grid,
                       return_value_policy policy, handle parent) {
   parent = policy_switch(policy, parent);  // reusing variable
   std::vector<tamaas::UInt> sizes = {grid.dataSize()};
   return array(sizes, grid.getInternalData(), parent).release();
 }
 
 /**
  * Type caster for grid classes
  * inspired by https://tinyurl.com/y8m47qh3 from T. De Geus
  * and pybind11/eigen.h
  */
 template <template <typename, tamaas::UInt> class G, typename T,
           tamaas::UInt dim>
 struct type_caster<G<T, dim>> {
   using type = G<T, dim>;
   using array_type =
       array_t<typename type::value_type, array::c_style | array::forcecast>;
 
 public:
   // NOLINTNEXTLINE(readability-else-after-return)
   PYBIND11_TYPE_CASTER(type, _("GridWrap<T, dim>"));
 
   /**
    * Conversion part 1 (Python->C++): convert a PyObject into a grid
    * instance or return false upon failure. The second argument
    * indicates whether implicit conversions should be applied.
    */
   bool load(handle src, bool convert) {
     if (!array_type::check_(src) or !convert)
       return false;
 
     auto buf = array_type::ensure(src);
     if (!buf)
       return false;
     value.move(tamaas::wrap::GridNumpy<G<T, dim>>(buf));
 
     return true;
   }
 
   /**
    * Conversion part 2 (C++ -> Python): convert a grid instance into
    * a Python object. The second and third arguments are used to
    * indicate the return value policy and parent object (for
    * ``return_value_policy::reference_internal``) and are generally
    * ignored by implicit casters.
    */
   static handle cast(const type& src, return_value_policy policy,
                      handle parent) {
     return grid_to_python<array_type>(src, policy, parent);
   }
 };
 
 /**
  * Type caster for GridBase classes
  */
 template <typename T>
 struct type_caster<tamaas::GridBase<T>> {
   using type = tamaas::GridBase<T>;
   using array_type =
       array_t<typename type::value_type, array::c_style | array::forcecast>;
 
 public:
   // NOLINTNEXTLINE(readability-else-after-return)
   PYBIND11_TYPE_CASTER(type, _("GridBaseWrap<T>"));
 
   bool load(handle src, bool convert) {
     if (!array_type::check_(src) or !convert)
       return false;
 
     auto buf = array_type::ensure(src);
     if (!buf)
       return false;
     value.move(tamaas::wrap::GridBaseNumpy<T>(buf));
 
     return true;
   }
 
   static handle cast(const type& src, return_value_policy policy,
                      handle parent) {
 #define GRID_BASE_CASE(unused1, unused2, dim)                                  \
   case dim: {                                                                  \
     const auto* conv = dynamic_cast<const tamaas::Grid<T, dim>*>(&src);        \
     if (conv)                                                                  \
       return grid_to_python<array_type>(*conv, policy, parent);                \
     else                                                                       \
       return grid_to_python<array_type>(src, policy, parent);                  \
   }
 
     switch (src.getDimension()) {
       BOOST_PP_SEQ_FOR_EACH(GRID_BASE_CASE, ~, (1)(2)(3));
     default:
       return grid_to_python<array_type>(src, policy, parent);
     }
 #undef GRID_BASE_CASE
   }
 };
 }  // namespace detail
 }  // namespace pybind11
 
 #endif  // CAST_HH
diff --git a/python/numpy.hh b/python/numpy.hh
index 0e8f591..d4e6aa1 100644
--- a/python/numpy.hh
+++ b/python/numpy.hh
@@ -1,92 +1,93 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef NUMPY_HH
 #define NUMPY_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_base.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
 namespace tamaas {
 
 namespace wrap {
 namespace py = pybind11;
 
 /// Type alias for usual numpy array type
 template <typename T>
 using numpy = py::array_t<T, py::array::c_style | py::array::forcecast>;
 
 /// GridBase helper class wrapping numpy array
 template <typename T>
 class GridBaseNumpy : public GridBase<T> {
 public:
   GridBaseNumpy(numpy<T>& buffer) : GridBase<T>() {
     this->nb_components = 1;
     this->data.wrapMemory(buffer.mutable_data(), buffer.size());
   }
 };
 
 /// Grid helper class wrapping numpy array
 template <class Parent>
 class GridNumpy : public Parent {
 public:
   GridNumpy(numpy<typename Parent::value_type>& buffer) : Parent() {
     auto* array_shape = buffer.shape();
     const UInt ndim = buffer.ndim();
 
     if (ndim > Parent::dimension + 1 || ndim < Parent::dimension)
       TAMAAS_EXCEPTION(
           "Numpy array dimension do not match expected grid dimensions");
 
     if (ndim == Parent::dimension + 1)
       this->nb_components = array_shape[ndim - 1];
 
     std::copy_n(array_shape, Parent::dimension, this->n.begin());
     this->computeStrides();
     this->data.wrapMemory(buffer.mutable_data(), this->computeSize());
   }
 };
 
 /// Surface helper class wrapping numpy array
 template <class Parent>
 class SurfaceNumpy : public Parent {
 public:
   SurfaceNumpy(numpy<typename Parent::value_type>& buffer) : Parent() {
     auto* array_shape = buffer.shape();
 
     if (buffer.ndim() != 2)
       TAMAAS_EXCEPTION(
           "Numpy array dimension do not match expected surface dimensions");
 
     std::copy_n(array_shape, Parent::dimension, this->n.begin());
     this->computeStrides();
     this->data.wrapMemory(buffer.mutable_data(), this->computeSize());
   }
 };
 
 }  // namespace wrap
 
 }  // namespace tamaas
 
 #endif  // NUMPY_HH
diff --git a/python/tamaas_module.cpp b/python/tamaas_module.cpp
index e2445b3..554dfe7 100644
--- a/python/tamaas_module.cpp
+++ b/python/tamaas_module.cpp
@@ -1,86 +1,87 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include "tamaas_info.hh"
 #include "wrap.hh"
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 namespace py = pybind11;
 
 namespace detail {
 template <typename T>
 struct dtype_helper {
   static const py::dtype dtype;
 };
 
 template <>
 const py::dtype dtype_helper<double>::dtype("=f8");
 template <>
 const py::dtype dtype_helper<long double>::dtype("=f16");
 }  // namespace detail
 
 /// Creating the tamaas python module
 PYBIND11_MODULE(_tamaas, mod) {
   mod.doc() = "Compiled component of Tamaas";
 
   // Wrapping the base methods
   mod.def("initialize", &initialize, py::arg("num_threads") = 0,
           "Initialize tamaas with desired number of threads. Automatically "
           "called upon import of the tamaas module, but can be manually called "
           "to set the desired number of threads.");
   mod.def("finalize", []() {
     PyErr_WarnEx(PyExc_DeprecationWarning,
                  "finalize() is deprecated, it is now automatically called "
                  "at the end of the program", 1);
   });
 
   // Default dtype of numpy arrays
   mod.attr("dtype") = detail::dtype_helper<Real>::dtype;
 
   // Wrapping release information
   auto info = py::class_<TamaasInfo>(mod, "TamaasInfo");
   info.attr("version") = TamaasInfo::version;
   info.attr("build_type") = TamaasInfo::build_type;
   info.attr("branch") = TamaasInfo::branch;
   info.attr("commit") = TamaasInfo::commit;
   info.attr("diff") = TamaasInfo::diff;
   info.attr("remotes") = TamaasInfo::remotes;
   info.attr("has_mpi") = TamaasInfo::has_mpi;
   info.attr("backend") = TamaasInfo::backend;
 
   // Wrapping tamaas components
   wrap::wrapCore(mod);
   wrap::wrapPercolation(mod);
   wrap::wrapSurface(mod);
   wrap::wrapModel(mod);
   wrap::wrapSolvers(mod);
   wrap::wrapCompute(mod);
   wrap::wrapMPI(mod);
 
   /// Wrapping test features
   wrap::wrapTestFeatures(mod);
 }
 
 }  // namespace tamaas
diff --git a/python/wrap.hh b/python/wrap.hh
index c6ac47d..4a18d8f 100644
--- a/python/wrap.hh
+++ b/python/wrap.hh
@@ -1,76 +1,77 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef WRAP_HH
 #define WRAP_HH
 /* -------------------------------------------------------------------------- */
 #include "cast.hh"
 #include "numpy.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace wrap {
 
 namespace py = pybind11;
 
 /// For naming classes templated with dimension
 inline std::string makeDimensionName(const std::string& name, UInt dim) {
   std::stringstream str;
   str << name << dim << "D";
   return str.str();
 }
 
 /* -------------------------------------------------------------------------- */
 /* Prototypes for wrapping of tamaas components */
 /* -------------------------------------------------------------------------- */
 void wrapCore(py::module& mod);
 void wrapPercolation(py::module& mod);
 void wrapSurface(py::module& mod);
 void wrapModel(py::module& mod);
 void wrapSolvers(py::module& mod);
 void wrapTestFeatures(py::module& mod);
 void wrapCompute(py::module& mod);
 void wrapMPI(py::module& mod);
 
 /* -------------------------------------------------------------------------- */
 /* Deprecation macro */
 /* -------------------------------------------------------------------------- */
 #define TAMAAS_DEPRECATE(olds, news)                                           \
   do {                                                                         \
     PyErr_WarnEx(PyExc_DeprecationWarning,                                     \
                  olds " is deprecated, use " news " instead.", 1);             \
   } while (0)
 
 #define TAMAAS_DEPRECATE_ACCESSOR(acc, type, property)                         \
 #acc, [](const type& m) -> decltype(m.acc()) {                       \
     TAMAAS_DEPRECATE(#acc "()", "the " property " property");                  \
     return m.acc();                                                            \
   }
 
 }  // namespace wrap
 
 }  // namespace tamaas
 
 #endif  // WRAP_HH
diff --git a/python/wrap/compute.cpp b/python/wrap/compute.cpp
index 666e9d5..fee8395 100644
--- a/python/wrap/compute.cpp
+++ b/python/wrap/compute.cpp
@@ -1,90 +1,91 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "computes.hh"
 #include "wrap.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 namespace wrap {
 
 using namespace py::literals;
 
 void wrapCompute(py::module& mod) {
   auto compute_mod = mod.def_submodule("compute");
   compute_mod.def(
       "eigenvalues",
       [](model_type type, Grid<Real, 3>& eigs, const Grid<Real, 3>& field) {
         eigenvalues(type, eigs, field);
       },
       "model_type"_a, "eigenvalues_out"_a, "field"_a,
       "Compute eigenvalues of a tensor field");
   compute_mod.def(
       "von_mises",
       [](model_type type, Grid<Real, 3>& vm, const Grid<Real, 3>& field) {
         vonMises(type, vm, field);
       },
       "model_type"_a, "von_mises"_a, "field"_a,
       "Compute the Von Mises invariant of a tensor field");
   compute_mod.def(
       "deviatoric",
       [](model_type type, Grid<Real, 3>& dev, const Grid<Real, 3>& field) {
         deviatoric(type, dev, field);
       },
       "model_type"_a, "deviatoric"_a, "field"_a,
       "Compute the deviatoric part of a tensor field");
 
   compute_mod.def(
       "to_voigt",
       [](const Grid<Real, 3>& field) {
         if (field.getNbComponents() != 9)
           TAMAAS_EXCEPTION("Wrong number of components to symmetrize");
 
         Grid<Real, 3> voigt(field.sizes(), 6);
         Loop::loop(
             [] CUDA_LAMBDA(MatrixProxy<const Real, 3, 3> in,
                            SymMatrixProxy<Real, 3> out) { out.symmetrize(in); },
             range<MatrixProxy<const Real, 3, 3>>(field),
             range<SymMatrixProxy<Real, 3>>(voigt));
         return voigt;
       },
       "Convert a 3D tensor field to voigt notation",
       py::return_value_policy::copy);
 
   compute_mod.def(
       "from_voigt",
       [](const Grid<Real, 3>& field) {
         if (field.getNbComponents() != 6)
           TAMAAS_EXCEPTION("Wrong number of components to symmetrize");
 
         Grid<Real, 3> full(field.sizes(), 9);
         Loop::loop([] CUDA_LAMBDA(
                        SymMatrixProxy<const Real, 3> in,
                        MatrixProxy<Real, 3, 3> out) { out.fromSymmetric(in); },
                    range<SymMatrixProxy<const Real, 3>>(field),
                    range<MatrixProxy<Real, 3, 3>>(full));
         return full;
       },
       "Convert a 3D tensor field to voigt notation",
       py::return_value_policy::copy);
 }
 }  // namespace wrap
 }  // namespace tamaas
diff --git a/python/wrap/core.cpp b/python/wrap/core.cpp
index e61c995..05a5a10 100644
--- a/python/wrap/core.cpp
+++ b/python/wrap/core.cpp
@@ -1,120 +1,121 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "logger.hh"
 #include "statistics.hh"
 #include "wrap.hh"
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 namespace wrap {
 
 using namespace py::literals;
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void wrapStatistics(py::module& mod) {
   auto name = makeDimensionName("Statistics", dim);
   py::class_<Statistics<dim>>(mod, name.c_str())
       .def_static("computePowerSpectrum",
                   &Statistics<dim>::computePowerSpectrum,
                   py::return_value_policy::move, "Compute PSD of surface")
       .def_static(
           "computeAutocorrelation", &Statistics<dim>::computeAutocorrelation,
           py::return_value_policy::move, "Compute autocorrelation of surface")
       .def_static("computeMoments", &Statistics<dim>::computeMoments,
                   "Compute spectral moments")
       .def_static("computeSpectralRMSSlope",
                   &Statistics<dim>::computeSpectralRMSSlope,
                   "Compute hrms' in Fourier space")
       .def_static("computeRMSHeights", &Statistics<dim>::computeRMSHeights,
                   "Compute hrms")
       .def_static("contact", &Statistics<dim>::contact, "tractions"_a,
                   "perimeter"_a = 0,
                   "Compute the (corrected) contact area. Permieter is the "
                   "total contact perimeter in number of segments.")
       .def_static("graphArea", &Statistics<dim>::graphArea, "zdisplacement"_a,
                   "Compute area defined by function graph.");
 }
 
 /* -------------------------------------------------------------------------- */
 void wrapCore(py::module& mod) {
   // Exposing logging facility
   py::enum_<LogLevel>(mod, "LogLevel")
       .value("debug", LogLevel::debug)
       .value("info", LogLevel::info)
       .value("warning", LogLevel::warning)
       .value("error", LogLevel::error);
   mod.def("set_log_level", [](LogLevel level) { Logger::setLevel(level); });
   mod.def("get_log_level", Logger::getCurrentLevel);
 
   py::class_<Logger>(mod, "Logger")
       .def(py::init<>())
       .def(
           "get",
           [](Logger& logger, LogLevel level) -> Logger& {
             logger.get(level);
             return logger;
           },
           "Get a logger object for a log level")
       .def(
           "__lshift__",
           [](Logger& logger, std::string msg) -> Logger& {
             auto level = logger.getWishLevel();
             if (level >= Logger::getCurrentLevel() and
                 not(mpi::rank() != 0 and level == LogLevel::info)) {
               py::print(msg,
                         "file"_a = py::module::import("sys").attr("stderr"));
             }
             return logger;
           },
           "Log a message");
 
   wrapStatistics<1>(mod);
   wrapStatistics<2>(mod);
 
   mod.def(
       "to_voigt",
       [](const Grid<Real, 3>& field) {
         TAMAAS_DEPRECATE("tamaas.to_voigt()", "tamaas.compute.to_voigt()");
 
         if (field.getNbComponents() == 9) {
           Grid<Real, 3> voigt(field.sizes(), 6);
           Loop::loop([] CUDA_LAMBDA(
                          MatrixProxy<const Real, 3, 3> in,
                          SymMatrixProxy<Real, 3> out) { out.symmetrize(in); },
                      range<MatrixProxy<const Real, 3, 3>>(field),
                      range<SymMatrixProxy<Real, 3>>(voigt));
           return voigt;
         }
 
         TAMAAS_EXCEPTION("Wrong number of components to symmetrize");
       },
       "Convert a 3D tensor field to voigt notation",
       py::return_value_policy::copy);
 }
 
 }  // namespace wrap
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/python/wrap/model.cpp b/python/wrap/model.cpp
index 3296dd5..ead4a54 100644
--- a/python/wrap/model.cpp
+++ b/python/wrap/model.cpp
@@ -1,516 +1,517 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 #include "adhesion_functional.hh"
 #include "elastic_functional.hh"
 #include "functional.hh"
 #include "integral_operator.hh"
 #include "model_dumper.hh"
 #include "model_extensions.hh"
 #include "model_factory.hh"
 #include "numpy.hh"
 #include "residual.hh"
 #include "wrap.hh"
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace wrap {
 
 using namespace py::literals;
 
 struct model_operator_accessor {
   Model& m;
 
   decltype(auto) get(const std::string& name) {
     return m.getIntegralOperator(name);
   }
 };
 
 /// Wrap functional classes
 void wrapFunctionals(py::module& mod) {
   py::class_<functional::Functional, std::shared_ptr<functional::Functional>,
              functional::wrap::PyFunctional>
       func(mod, "Functional");
   func.def(py::init<>())
       .def("computeF", &functional::Functional::computeF,
            "Compute functional value")
       .def("computeGradF", &functional::Functional::computeGradF,
            "Compute functional gradient");
 
   py::class_<functional::ElasticFunctionalPressure>(
       mod, "ElasticFunctionalPressure", func)
       .def(py::init<const IntegralOperator&, const GridBase<Real>&>());
   py::class_<functional::ElasticFunctionalGap>(mod, "ElasticFunctionalGap",
                                                func)
       .def(py::init<const IntegralOperator&, const GridBase<Real>&>());
 
   py::class_<functional::AdhesionFunctional> adh(mod, "AdhesionFunctional",
                                                  func);
   adh.def_property("parameters", &functional::AdhesionFunctional::getParameters,
                    &functional::AdhesionFunctional::setParameters,
                    "Parameters dictionary")
       .def("setParameters", [](functional::AdhesionFunctional& f,
                                const std::map<std::string, Real>& m) {
         TAMAAS_DEPRECATE("setParameters()", "the parameters property");
         f.setParameters(m);
       });
 
   py::class_<functional::ExponentialAdhesionFunctional>(
       mod, "ExponentialAdhesionFunctional", adh,
       "Potential of the form F = -γ·exp(-g/ρ)")
       .def(py::init<const GridBase<Real>&>(), "surface"_a);
   py::class_<functional::MaugisAdhesionFunctional>(
       mod, "MaugisAdhesionFunctional", adh,
       "Cohesive zone potential F = H(g - ρ)·γ/ρ")
       .def(py::init<const GridBase<Real>&>(), "surface"_a);
   py::class_<functional::SquaredExponentialAdhesionFunctional>(
       mod, "SquaredExponentialAdhesionFunctional", adh,
       "Potential of the form F = -γ·exp(-0.5·(g/ρ)²)")
       .def(py::init<const GridBase<Real>&>(), "surface"_a);
 }
 
 template <typename T>
 std::unique_ptr<GridBase<T>> instanciateFromNumpy(numpy<T>& num) {
   std::unique_ptr<GridBase<T>> result = nullptr;
 
   switch (num.ndim()) {
   case 2:
     result = std::make_unique<GridNumpy<Grid<T, 1>>>(num);
     return result;
   case 3:
     result = std::make_unique<GridNumpy<Grid<T, 2>>>(num);
     return result;
   case 4:
     result = std::make_unique<GridNumpy<Grid<T, 3>>>(num);
     return result;
   default:
     TAMAAS_EXCEPTION("instanciateFromNumpy expects the last dimension of numpy "
                      "array to be the number of components");
   }
 }
 
 /// Wrap IntegralOperator
 void wrapIntegralOperator(py::module& mod) {
   py::class_<IntegralOperator>(mod, "IntegralOperator")
       .def("apply",
            [](IntegralOperator& op, numpy<Real> input, numpy<Real> output) {
              TAMAAS_DEPRECATE("apply()", "the () operator");
              auto in = instanciateFromNumpy(input);
              auto out = instanciateFromNumpy(output);
 
              op.apply(*in, *out);
            })
       .def(TAMAAS_DEPRECATE_ACCESSOR(getModel, IntegralOperator, "model"),
            py::return_value_policy::reference)
       .def(TAMAAS_DEPRECATE_ACCESSOR(getKind, IntegralOperator, "kind"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getType, IntegralOperator, "type"))
 
       .def(
           "__call__",
           [](IntegralOperator& op, numpy<Real> input, numpy<Real> output) {
             auto in = instanciateFromNumpy(input);
             auto out = instanciateFromNumpy(output);
 
             op.apply(*in, *out);
           },
           "Apply the integral operator")
       .def("updateFromModel", &IntegralOperator::updateFromModel,
            "Resets internal persistent variables from the model")
 
       .def_property_readonly("kind", &IntegralOperator::getKind)
       .def_property_readonly("model", &IntegralOperator::getModel)
       .def_property_readonly("type", &IntegralOperator::getType)
       .def_property_readonly("shape", &IntegralOperator::matvecShape)
       .def(
           "matvec",
           [](const IntegralOperator& op, numpy<Real> X) -> GridBase<Real> {
             GridBaseNumpy<Real> x(X);
             auto y = op.matvec(x);
             return y;
           },
           py::return_value_policy::move);
 
   py::enum_<integration_method>(mod, "integration_method",
                                 "Integration method used for the computation "
                                 "of volumetric Fourier operators")
       .value("linear", integration_method::linear,
              "No approximation error, O(N₁·N₂·N₃) time complexity, may cause "
              "float overflow/underflow")
       .value("cutoff", integration_method::cutoff,
              "Approximation, O(sqrt(N₁²+N₂²)·N₃²) time complexity, no "
              "overflow/underflow risk");
 }
 
 /// Wrap BEEngine classes
 void wrapBEEngine(py::module& mod) {
   py::class_<BEEngine>(mod, "BEEngine")
       .def("solveNeumann", &BEEngine::solveNeumann)
       .def("solveDirichlet", &BEEngine::solveDirichlet)
       .def("registerNeumann", &BEEngine::registerNeumann)
       .def("registerDirichlet", &BEEngine::registerDirichlet)
       .def(TAMAAS_DEPRECATE_ACCESSOR(getModel, BEEngine, "model"),
            py::return_value_policy::reference)
 
       .def_property_readonly("model", &BEEngine::getModel);
 }
 
 template <model_type type>
 void wrapModelTypeTrait(py::module& mod) {
   using trait = model_type_traits<type>;
   py::class_<trait>(mod, trait::repr)
       .def_property_readonly_static(
           "dimension", [](const py::object&) { return trait::dimension; },
           "Dimension of computational domain")
       .def_property_readonly_static(
           "components", [](const py::object&) { return trait::components; },
           "Number of components of vector fields")
       .def_property_readonly_static(
           "boundary_dimension",
           [](const py::object&) { return trait::boundary_dimension; },
           "Dimension of boundary of computational domain")
       .def_property_readonly_static(
           "voigt", [](const py::object&) { return trait::voigt; },
           "Number of components of symmetrical tensor fields")
       .def_property_readonly_static(
           "indices", [](const py::object&) { return trait::indices; });
 }
 
 /// Wrap Models
 void wrapModelClass(py::module& mod) {
   py::enum_<model_type>(mod, "model_type")
       .value("basic_1d", model_type::basic_1d,
              "Normal contact with 1D interface")
       .value("basic_2d", model_type::basic_2d,
              "Normal contact with 2D interface")
       .value("surface_1d", model_type::surface_1d,
              "Normal & tangential contact with 1D interface")
       .value("surface_2d", model_type::surface_2d,
              "Normal & tangential contact with 2D interface")
       .value("volume_1d", model_type::volume_1d,
              "Contact with volumetric representation and 1D interface")
       .value("volume_2d", model_type::volume_2d,
              "Contact with volumetric representation and 2D interface");
 
   auto trait_mod = mod.def_submodule("_type_traits");
   wrapModelTypeTrait<model_type::basic_1d>(trait_mod);
   wrapModelTypeTrait<model_type::surface_1d>(trait_mod);
   wrapModelTypeTrait<model_type::volume_1d>(trait_mod);
   wrapModelTypeTrait<model_type::basic_2d>(trait_mod);
   wrapModelTypeTrait<model_type::surface_2d>(trait_mod);
   wrapModelTypeTrait<model_type::volume_2d>(trait_mod);
 
   py::class_<model_operator_accessor>(mod, "_model_operator_acessor")
       .def(py::init<Model&>())
       .def(
           "__getitem__",
           [](model_operator_accessor& acc, std::string name) {
             try {
               return acc.get(name);
             } catch (std::out_of_range&) {
               throw py::key_error(name);
             }
           },
           py::return_value_policy::reference_internal)
       .def("__contains__",
            [](model_operator_accessor& acc, std::string key) {
              const auto ops = acc.m.getIntegralOperators();
              return std::find(ops.begin(), ops.end(), key) != ops.end();
            })
       .def(
           "__iter__",
           [](const model_operator_accessor& acc) {
             const auto& ops = acc.m.getIntegralOperatorsMap();
             return py::make_key_iterator(ops.cbegin(), ops.cend());
           },
           py::keep_alive<0, 1>());
 
   py::class_<Model>(mod, "Model")
       .def(py::init(py::overload_cast<model_type, const std::vector<Real>&,
                                       const std::vector<UInt>&>(
           &ModelFactory::createModel)))
       .def_property_readonly("type", &Model::getType)
       .def_property("E", &Model::getYoungModulus, &Model::setYoungModulus,
                     "Young's modulus")
       .def_property("nu", &Model::getPoissonRatio, &Model::setPoissonRatio,
                     "Poisson's ratio")
       .def_property_readonly("mu", &Model::getShearModulus, "Shear modulus")
       .def_property_readonly("E_star", &Model::getHertzModulus,
                              "Contact (Hertz) modulus")
       .def_property_readonly("be_engine", &Model::getBEEngine,
                              "Boundary element engine")
 
       .def(
           "setElasticity",
           [](Model& m, Real E, Real nu) {
             TAMAAS_DEPRECATE("setElasticity()", "the E and nu properties");
             m.setElasticity(E, nu);
           },
           "E"_a, "nu"_a)
       .def(TAMAAS_DEPRECATE_ACCESSOR(getHertzModulus, Model, "E_star"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getYoungModulus, Model, "E"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getShearModulus, Model, "mu"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getPoissonRatio, Model, "nu"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getTraction, Model, "traction"),
            py::return_value_policy::reference_internal)
       .def(TAMAAS_DEPRECATE_ACCESSOR(getDisplacement, Model, "displacement"),
            py::return_value_policy::reference_internal)
       .def(TAMAAS_DEPRECATE_ACCESSOR(getSystemSize, Model, "system_size"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getDiscretization, Model, "shape"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getBoundarySystemSize, Model,
                                      "boundary_system_size"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getBoundaryDiscretization, Model,
                                      "boundary_shape"))
 
       .def("solveNeumann", &Model::solveNeumann,
            "Solve surface tractions -> displacements")
       .def("solveDirichlet", &Model::solveDirichlet,
            "Solve surface displacemnts -> tractions")
       .def("dump", &Model::dump, "Write model data to registered dumpers")
       .def("addDumper", &Model::addDumper, "dumper"_a, py::keep_alive<1, 2>(),
            "Register a dumper")
 
       .def(
           "getBEEngine",
           [](Model& m) -> decltype(m.getBEEngine()) {
             TAMAAS_DEPRECATE("getBEEngine()", "the be_engine property");
             return m.getBEEngine();
           },
           py::return_value_policy::reference_internal)
       .def(
           "getIntegralOperator",
           [](const Model& m, std::string name) {
             TAMAAS_DEPRECATE("getIntegralOperator()", "the operators property");
             return m.getIntegralOperator(name);
           },
           "operator_name"_a, py::return_value_policy::reference_internal)
       .def(
           "registerField",
           [](Model& m, std::string name, numpy<Real> field) {
             TAMAAS_DEPRECATE("registerField()", "the [] operator");
             auto f = instanciateFromNumpy(field);
             m.registerField(name, std::move(f));
           },
           "field_name"_a, "field"_a, py::keep_alive<1, 3>())
       .def(
           "getField",
           [](const Model& m, std::string name) -> decltype(m.getField(name)) {
             TAMAAS_DEPRECATE("getField()", "the [] operator");
             return m.getField(name);
           },
           "field_name"_a, py::return_value_policy::reference_internal)
       .def(
           "getFields",
           [](const Model& m) {
             TAMAAS_DEPRECATE("getFields()", "list(model)");
             return m.getFields();
           },
           "Return fields list")
 
       .def(
           "applyElasticity",
           [](Model& model, numpy<Real> stress, numpy<Real> strain) {
             auto out = instanciateFromNumpy(stress);
             auto in = instanciateFromNumpy(strain);
 
             model.applyElasticity(*out, *in);
           },
           "Apply Hooke's law")
 
       // Python magic functions
       .def("__repr__",
            [](const Model& m) {
              std::stringstream ss;
              ss << m;
              return ss.str();
            })
       .def(
           "__getitem__",
           [](const Model& m, std::string key) -> decltype(m[key]) {
             try {
               return m[key];
             } catch (std::out_of_range&) {
               throw py::key_error(key);
             }
           },
           py::return_value_policy::reference_internal, "Get field")
       .def(
           "__setitem__",
           [](Model& m, std::string name, numpy<Real> field) {
             auto f = instanciateFromNumpy(field);
             m.registerField(name, std::move(f));
           },
           py::keep_alive<1, 3>(), "Register new field")
       .def(
           "__contains__",
           [](const Model& m, std::string key) {
             const auto fields = m.getFields();
             return std::find(fields.begin(), fields.end(), key) != fields.end();
           },
           py::keep_alive<0, 1>(), "Test field existence")
       .def(
           "__iter__",
           [](const Model& m) {
             const auto& fields = m.getFieldsMap();
             return py::make_key_iterator(fields.cbegin(), fields.cend());
           },
           py::keep_alive<0, 1>(), "Iterator on fields")
       .def(
           "__copy__",
           [](const Model&) {
             throw std::runtime_error("__copy__ not implemented");
           },
           "Shallow copy of model. Not implemented.")
       .def(
           "__deepcopy__",
           [](const Model& m, py::dict) { return ModelFactory::createModel(m); },
           "Deep copy of model.")
       .def_property_readonly("boundary_fields", &Model::getBoundaryFields)
       .def_property_readonly(
           "operators", [](Model& m) { return model_operator_accessor{m}; },
           "Returns a dict-like object allowing access to the model's "
           "integral "
           "operators")
       // More python-like access to model properties
       .def_property_readonly("shape", &Model::getDiscretization,
                              "Discretization (local in MPI environment)")
       .def_property_readonly("global_shape", &Model::getGlobalDiscretization,
                              "Global discretization (in MPI environement)")
       .def_property_readonly("boundary_shape",
                              &Model::getBoundaryDiscretization,
                              "Number of points on boundary")
       .def_property_readonly("system_size", &Model::getSystemSize,
                              "Size of physical domain")
       .def_property_readonly("boundary_system_size",
                              &Model::getBoundarySystemSize,
                              "Physical size of surface")
       .def_property_readonly("traction",
                              (const GridBase<Real>& (Model::*)() const) &
                                  Model::getTraction,
                              "Surface traction field")
       .def_property_readonly("displacement",
                              (const GridBase<Real>& (Model::*)() const) &
                                  Model::getDisplacement,
                              "Displacement field");
 
   py::class_<ModelDumper, PyModelDumper, std::shared_ptr<ModelDumper>>(
       mod, "ModelDumper")
       .def(py::init<>())
       .def("dump", &ModelDumper::dump, "model"_a, "Dump model")
       .def(
           "__lshift__",
           [](ModelDumper& dumper, Model& model) { dumper << model; },
           "Dump model");
 }
 
 /// Wrap factory for models
 void wrapModelFactory(py::module& mod) {
   py::class_<ModelFactory>(mod, "ModelFactory")
       .def_static(
           "createModel",
           py::overload_cast<model_type, const std::vector<Real>&,
                             const std::vector<UInt>&>(
               &ModelFactory::createModel),
           "model_type"_a, "system_size"_a, "global_discretization"_a,
           R"-(Create a new model of a given type, physical size and *global*
 discretization.
 
 :param model_type: the type of desired model
 :param system_size: the physical size of the domain in each direction
 :param global_discretization: number of points in each direction)-")
       .def_static("createModel",
                   py::overload_cast<const Model&>(&ModelFactory::createModel),
                   "model"_a, "Create a deep copy of a model.")
       .def_static("createResidual", &ModelFactory::createResidual, "model"_a,
                   "sigma_y"_a, "hardening"_a = 0.,
                   R"-(Create an isotropic linear hardening residual.
 :param model: the model on which to define the residual
 :param sigma_y: the (von Mises) yield stress
 :param hardening: the hardening modulus)-")
       .def_static("registerVolumeOperators",
                   &ModelFactory::registerVolumeOperators, "model"_a,
                   "Register Boussinesq and Mindlin operators to model.");
 }
 
 /// Wrap residual class
 void wrapResidual(py::module& mod) {
   // TODO adapt to n-dim
   py::class_<Residual, PyResidual>(mod, "Residual")
       .def(py::init<Model*>())
       .def("computeResidual",
            [](Residual& res, numpy<Real>& x) {
              auto in = instanciateFromNumpy(x);
              res.computeResidual(*in);
            })
       .def("computeStress",
            [](Residual& res, numpy<Real>& x) {
              auto in = instanciateFromNumpy(x);
              res.computeStress(*in);
            })
       .def("updateState",
            [](Residual& res, numpy<Real>& x) {
              auto in = instanciateFromNumpy(x);
              res.updateState(*in);
            })
       .def("computeResidualDisplacement",
            [](Residual& res, numpy<Real>& x) {
              auto in = instanciateFromNumpy(x);
              res.computeResidualDisplacement(*in);
            })
       .def(
           "applyTangent",
           [](Residual& res, numpy<Real>& output, numpy<Real>& input,
              numpy<Real>& current_strain_inc) {
             auto out = instanciateFromNumpy(output);
             auto in = instanciateFromNumpy(input);
             auto inc = instanciateFromNumpy(current_strain_inc);
             res.applyTangent(*out, *in, *inc);
           },
           "output"_a, "input"_a, "current_strain_increment"_a)
       .def("getVector", &Residual::getVector,
            py::return_value_policy::reference_internal)
       .def("getPlasticStrain", &Residual::getPlasticStrain,
            py::return_value_policy::reference_internal)
       .def("getStress", &Residual::getStress,
            py::return_value_policy::reference_internal)
       .def("setIntegrationMethod", &Residual::setIntegrationMethod, "method"_a,
            "cutoff"_a = 1e-12)
       .def_property("yield_stress", &Residual::getYieldStress,
                     &Residual::setYieldStress)
       .def_property("hardening_modulus", &Residual::getHardeningModulus,
                     &Residual::setHardeningModulus)
       .def_property_readonly("model", &Residual::getModel);
 }
 
 void wrapModel(py::module& mod) {
   wrapBEEngine(mod);
   wrapModelClass(mod);
   wrapModelFactory(mod);
   wrapFunctionals(mod);
   wrapResidual(mod);
   wrapIntegralOperator(mod);
 }
 
 }  // namespace wrap
 
 }  // namespace tamaas
diff --git a/python/wrap/model_extensions.hh b/python/wrap/model_extensions.hh
index 9ff457d..09debbd 100644
--- a/python/wrap/model_extensions.hh
+++ b/python/wrap/model_extensions.hh
@@ -1,147 +1,148 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "functional.hh"
 #include "model.hh"
 #include "model_dumper.hh"
 #include "residual.hh"
 #include "wrap.hh"
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 namespace functional {
 namespace wrap {
 /// Class for extension of Functional in python
 class PyFunctional : public Functional {
 public:
   using Functional::Functional;
 
   // Overriding pure virtual functions
   Real computeF(GridBase<Real>& variable, GridBase<Real>& dual) const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(Real, Functional, computeF, variable, dual);
   }
 
   void computeGradF(GridBase<Real>& variable,
                     GridBase<Real>& gradient) const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Functional, computeGradF, variable, gradient);
   }
 };
 }  // namespace wrap
 }  // namespace functional
 /* -------------------------------------------------------------------------- */
 namespace wrap {
 
 /* -------------------------------------------------------------------------- */
 class PyModelDumper : public ModelDumper {
 public:
   using ModelDumper::ModelDumper;
 
   void dump(const Model& model) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, ModelDumper, dump, model);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 class PyResidual : public Residual {
 public:
   using Residual::Residual;
 
   void computeResidual(GridBase<Real>& strain_increment) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, computeResidual, strain_increment);
   }
 
   void applyTangent(GridBase<Real>& output, GridBase<Real>& input,
                     GridBase<Real>& current_strain_increment) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, applyTangent, output, input,
                            current_strain_increment);
   }
 
   void computeStress(GridBase<Real>& strain_increment) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, computeStress, strain_increment);
   }
 
   void updateState(GridBase<Real>& converged_strain_increment) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, updateState,
                            converged_strain_increment);
   }
 
   const GridBase<Real>& getVector() const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(const GridBase<Real>&, Residual, getVector);
   }
 
   const GridBase<Real>& getPlasticStrain() const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(const GridBase<Real>&, Residual, getPlasticStrain);
   }
 
   const GridBase<Real>& getStress() const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(const GridBase<Real>&, Residual, getStress);
   }
 
   void computeResidualDisplacement(GridBase<Real>& strain_increment) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, computeResidualDisplacement,
                            strain_increment);
   }
 
   void setIntegrationMethod(integration_method method, Real cutoff) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, setIntegrationMethod, method,
                            cutoff);
   }
 
   Real getYieldStress() const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(Real, Residual, getYieldStress);
   }
 
   Real getHardeningModulus() const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(Real, Residual, getHardeningModulus);
   }
 
   void setYieldStress(Real val) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, setYieldStress, val);
   }
 
   void setHardeningModulus(Real val) override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Residual, setHardeningModulus, val);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 
 }  // namespace wrap
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/python/wrap/mpi.cpp b/python/wrap/mpi.cpp
index d0c2a83..b36ad30 100644
--- a/python/wrap/mpi.cpp
+++ b/python/wrap/mpi.cpp
@@ -1,100 +1,101 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mpi_interface.hh"
 #include "partitioner.hh"
 #include "wrap.hh"
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 namespace wrap {
 
 using namespace py::literals;
 
 /* -------------------------------------------------------------------------- */
 void wrapMPI(py::module& mod) {
   auto mpi_mod = mod.def_submodule("mpi");
   py::class_<mpi::sequential>(mpi_mod, "sequential")
       .def(py::init<>())
       .def("__enter__",
            [](mpi::sequential& /*obj*/) { mpi::sequential::enter(); })
       .def("__exit__", [](mpi::sequential& /*obj*/, py::object /*unused*/,
                           py::object /*unused*/,
                           py::object /*unused*/) { mpi::sequential::exit(); });
   mpi_mod.def(
       "local_shape",
       [](std::vector<UInt> global) {
         switch (global.size()) {
         case 1:
           return Partitioner<1>::local_size(global);
         case 2:
           return Partitioner<2>::local_size(global);
         default:
           TAMAAS_EXCEPTION("Please provide a 1D/2D shape");
         }
       },
       "global_shape"_a, "Gives the local size of a 1D/2D global shape");
   mpi_mod.def(
       "global_shape",
       [](std::vector<UInt> local) {
         switch (local.size()) {
         case 1:
           return Partitioner<1>::global_size(local);
         case 2:
           return Partitioner<2>::global_size(local);
         default:
           TAMAAS_EXCEPTION("Please provide a 1D/2D shape");
         }
       },
       "local_shape"_a, "Gives the global shape of a 1D/2D local shape");
 
   mpi_mod.def(
       "local_offset",
       [](std::vector<UInt> global) {
         switch (global.size()) {
         case 1:
           return Partitioner<1>::local_offset(global);
         case 2:
           return Partitioner<2>::local_offset(global);
         default:
           TAMAAS_EXCEPTION("Please provide a 1D/2D shape");
         }
       },
       "global_shape"_a, "Gives the local offset of a 1D/2D global shape");
   mpi_mod.def("gather", &Partitioner<2>::gather<Real>,
               py::return_value_policy::move, "Gather 2D surfaces");
   mpi_mod.def("scatter", &Partitioner<2>::scatter<Real>,
               py::return_value_policy::move, "Scatter 2D surfaces");
 
   mpi_mod.def(
       "size", []() { return mpi::size(); },
       "Returns the number of MPI processes");
   mpi_mod.def(
       "rank", []() { return mpi::rank(); },
       "Returns the rank of the local process");
 }
 
 }  // namespace wrap
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/python/wrap/percolation.cpp b/python/wrap/percolation.cpp
index 210f17c..fd1aa79 100644
--- a/python/wrap/percolation.cpp
+++ b/python/wrap/percolation.cpp
@@ -1,92 +1,93 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "flood_fill.hh"
 #include "wrap.hh"
 /* -------------------------------------------------------------------------- */
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace wrap {
 
 /* -------------------------------------------------------------------------- */
 using namespace py::literals;
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void wrapCluster(py::module& mod) {
   auto name = makeDimensionName("Cluster", dim);
   py::class_<Cluster<dim>>(mod, name.c_str())
       .def(py::init<>())
       .def_property_readonly("area", &Cluster<dim>::getArea, "Area of cluster")
       .def_property_readonly("points", &Cluster<dim>::getPoints,
                              "Get list of points of cluster")
       .def_property_readonly("perimeter", &Cluster<dim>::getPerimeter,
                              "Get perimeter of cluster")
       .def_property_readonly("bounding_box", &Cluster<dim>::boundingBox,
                              "Compute the bounding box of a cluster")
 
       .def(TAMAAS_DEPRECATE_ACCESSOR(getArea, Cluster<dim>, "area"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getPoints, Cluster<dim>, "points"))
       .def(TAMAAS_DEPRECATE_ACCESSOR(getPerimeter, Cluster<dim>, "perimeter"))
 
       .def("__str__", [](const Cluster<dim>& cluster) {
         std::stringstream sstr;
         sstr << '{';
         auto&& points = cluster.getPoints();
         auto print_point = [&sstr](const auto& point) {
           sstr << '(';
           for (UInt i = 0; i < point.size() - 1; ++i)
             sstr << point[i] << ", ";
           sstr << point.back() << ')';
         };
 
         auto point_it = points.begin();
         for (UInt p = 0; p < points.size() - 1; ++p) {
           print_point(*(point_it++));
           sstr << ", ";
         }
         print_point(points.back());
         sstr << "}";
         return sstr.str();
       });
 }
 
 void wrapPercolation(py::module& mod) {
   wrapCluster<1>(mod);
   wrapCluster<2>(mod);
   wrapCluster<3>(mod);
 
   py::class_<FloodFill>(mod, "FloodFill")
       .def_static("getSegments", &FloodFill::getSegments,
                   "Return a list of segments from boolean map", "contact"_a)
       .def_static("getClusters", &FloodFill::getClusters,
                   "Return a list of clusters from boolean map", "contact"_a,
                   "diagonal"_a)
       .def_static("getVolumes", &FloodFill::getVolumes,
                   "Return a list of volume clusters", "map"_a, "diagonal"_a);
 }
 
 }  // namespace wrap
 
 }  // namespace tamaas
diff --git a/python/wrap/solvers.cpp b/python/wrap/solvers.cpp
index 769718d..3f9e3c0 100644
--- a/python/wrap/solvers.cpp
+++ b/python/wrap/solvers.cpp
@@ -1,238 +1,239 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "beck_teboulle.hh"
 #include "condat.hh"
 #include "contact_solver.hh"
 #include "dfsane_solver.hh"
 #include "ep_solver.hh"
 #include "epic.hh"
 #include "kato.hh"
 #include "kato_saturated.hh"
 #include "polonsky_keer_rey.hh"
 #include "polonsky_keer_tan.hh"
 #include "wrap.hh"
 
 #include <pybind11/iostream.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace wrap {
 
 /* -------------------------------------------------------------------------- */
 using namespace py::literals;
 
 class PyEPSolver : public EPSolver {
 public:
   using EPSolver::EPSolver;
   // NOLINTNEXTLINE(readability-else-after-return)
   void solve() override { PYBIND11_OVERLOAD_PURE(void, EPSolver, solve); }
 
   void updateState() override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD(void, EPSolver, updateState);
   }
 };
 
 class PyContactSolver : public ContactSolver {
 public:
   using ContactSolver::ContactSolver;
 
   Real solve(std::vector<Real> load) override {
     PYBIND11_OVERLOAD(Real, ContactSolver, solve, load);
   }
 
   Real solve(Real load) override {
     PYBIND11_OVERLOAD(Real, ContactSolver, solve, load);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 void wrapSolvers(py::module& mod) {
   py::class_<ContactSolver, PyContactSolver>(mod, "ContactSolver")
       .def(py::init<Model&, const GridBase<Real>&, Real>(),
            py::keep_alive<1, 2>(), py::keep_alive<1, 3>())
       .def(
           "setMaxIterations",
           [](ContactSolver& m, UInt iter) {
             TAMAAS_DEPRECATE("setMaxIterations()", "the max_iter property");
             m.setMaxIterations(iter);
           },
           "max_iter"_a)
       .def(
           "setDumpFrequency",
           [](ContactSolver& m, UInt freq) {
             TAMAAS_DEPRECATE("setDumpFrequency()", "the dump_freq property");
             m.setDumpFrequency(freq);
           },
           "dump_freq"_a)
 
       .def_property("tolerance", &ContactSolver::getTolerance,
                     &ContactSolver::setTolerance, "Solver tolerance")
       .def_property("max_iter", &ContactSolver::getMaxIterations,
                     &ContactSolver::setMaxIterations,
                     "Maximum number of iterations")
       .def_property("dump_freq", &ContactSolver::getDumpFrequency,
                     &ContactSolver::setDumpFrequency,
                     "Frequency of displaying solver info")
       .def_property_readonly("model", &ContactSolver::getModel)
       .def_property_readonly("surface", &ContactSolver::getSurface)
       .def_property_readonly("functional", &ContactSolver::getFunctional)
       .def("addFunctionalTerm", &ContactSolver::addFunctionalTerm,
            "Add a term to the contact functional to minimize")
       .def("solve", py::overload_cast<std::vector<Real>>(&ContactSolver::solve),
            "target_force"_a,
            py::call_guard<py::scoped_ostream_redirect,
                           py::scoped_estream_redirect>(),
            "Solve the contact for a mean traction/gap vector")
       .def("solve", py::overload_cast<Real>(&ContactSolver::solve),
            "target_normal_pressure"_a,
            py::call_guard<py::scoped_ostream_redirect,
                           py::scoped_estream_redirect>(),
            "Solve the contact for a mean normal pressure/gap");
 
   py::class_<PolonskyKeerRey, ContactSolver> pkr(
       mod, "PolonskyKeerRey",
       "Main solver class for normal elastic contact problems. Its functional "
       "can be customized to add an adhesion term, and its primal variable can "
       "be set to either the gap or the pressure.");
   // Need to export enum values before defining PKR constructor
   py::enum_<PolonskyKeerRey::type>(pkr, "type")
       .value("gap", PolonskyKeerRey::gap)
       .value("pressure", PolonskyKeerRey::pressure)
       .export_values();
 
   pkr.def(py::init<Model&, const GridBase<Real>&, Real, PolonskyKeerRey::type,
                    PolonskyKeerRey::type>(),
           "model"_a, "surface"_a, "tolerance"_a,
           "primal_type"_a = PolonskyKeerRey::type::pressure,
           "constraint_type"_a = PolonskyKeerRey::type::pressure,
           py::keep_alive<1, 2>(), py::keep_alive<1, 3>())
       .def("computeError", &PolonskyKeerRey::computeError);
 
   py::class_<KatoSaturated, PolonskyKeerRey>(
       mod, "KatoSaturated",
       "Solver for pseudo-plasticity problems where the normal pressure is "
       "constrained above by a saturation pressure \"pmax\"")
       .def(py::init<Model&, const GridBase<Real>&, Real, Real>(), "model"_a,
            "surface"_a, "tolerance"_a, "pmax"_a, py::keep_alive<1, 2>(),
            py::keep_alive<1, 3>())
       .def_property("pmax", &KatoSaturated::getPMax, &KatoSaturated::setPMax,
                     "Saturation normal pressure");
 
   py::class_<Kato, ContactSolver> kato(mod, "Kato");
   kato.def(py::init<Model&, const GridBase<Real>&, Real, Real>(), "model"_a,
            "surface"_a, "tolerance"_a, "mu"_a, py::keep_alive<1, 2>(),
            py::keep_alive<1, 3>())
       .def("solve", &Kato::solve, "p0"_a, "proj_iter"_a = 50)
       .def("solveRelaxed", &Kato::solveRelaxed, "g0"_a)
       .def("solveRegularized", &Kato::solveRegularized, "p0"_a, "r"_a = 0.01)
       .def("computeCost", &Kato::computeCost, "use_tresca"_a = false);
 
   py::class_<BeckTeboulle, ContactSolver> bt(mod, "BeckTeboulle");
   bt.def(py::init<Model&, const GridBase<Real>&, Real, Real>(), "model"_a,
          "surface"_a, "tolerance"_a, "mu"_a, py::keep_alive<1, 2>(),
          py::keep_alive<1, 3>())
       .def("solve", &BeckTeboulle::solve, "p0"_a)
       .def("computeCost", &BeckTeboulle::computeCost);
 
   py::class_<Condat, ContactSolver> cd(
       mod, "Condat",
       "Main solver for frictional contact problems. It has no restraint on the "
       "material properties or friction coefficient values, but solves an "
       "associated version of the Coulomb friction law, which differs from the "
       "traditional Coulomb friction in that the normal and tangential slip "
       "components are coupled.");
   cd.def(py::init<Model&, const GridBase<Real>&, Real, Real>(), "model"_a,
          "surface"_a, "tolerance"_a, "mu"_a, py::keep_alive<1, 2>(),
          py::keep_alive<1, 3>())
       .def("solve", &Condat::solve, "p0"_a, "grad_step"_a = 0.9)
       .def("computeCost", &Condat::computeCost);
 
   py::class_<PolonskyKeerTan, ContactSolver> pkt(mod, "PolonskyKeerTan");
   pkt.def(py::init<Model&, const GridBase<Real>&, Real, Real>(), "model"_a,
           "surface"_a, "tolerance"_a, "mu"_a, py::keep_alive<1, 2>(),
           py::keep_alive<1, 3>())
       .def("solve", &PolonskyKeerTan::solve, "p0"_a)
       .def("solveTresca", &PolonskyKeerTan::solveTresca, "p0"_a)
       .def("computeCost", &PolonskyKeerTan::computeCost,
            "use_tresca"_a = false);
 
   py::class_<ToleranceManager>(
       mod, "_tolerance_manager",
       "Manager object for the tolereance of nonlinear plasticity solvers. "
       "Decreases the solver tolerance by geometric progression.")
       .def(py::init<Real, Real, Real>(), "start_tol"_a, "end_tol"_a, "rate"_a);
 
   py::class_<EPSolver, PyEPSolver>(
       mod, "EPSolver", "Mother class for nonlinear plasticity solvers")
       .def(py::init<Residual&>(), "residual"_a, py::keep_alive<1, 2>())
       .def("solve", &EPSolver::solve)
       .def("getStrainIncrement", &EPSolver::getStrainIncrement,
            py::return_value_policy::reference_internal)
       .def("getResidual", &EPSolver::getResidual,
            py::return_value_policy::reference_internal)
       .def("updateState", &EPSolver::updateState)
       .def_property("tolerance", &EPSolver::getTolerance,
                     &EPSolver::setTolerance)
       .def("setToleranceManager", &EPSolver::setToleranceManager)
       .def("beforeSolve", &EPSolver::beforeSolve);
 
   py::class_<DFSANESolver, EPSolver>(mod, "_DFSANESolver")
       .def(py::init<Residual&>(), "residual"_a, py::keep_alive<1, 2>())
       .def(py::init([](Residual& res, Model&) {
              return std::make_unique<DFSANESolver>(res);
            }),
            "residual"_a, "model"_a, py::keep_alive<1, 2>(),
            "Deprecated constructor: only here for compatibility reasons");
 
   py::class_<EPICSolver>(
       mod, "EPICSolver",
       "Main solver class for elastic-plastic contact problems")
       .def(py::init<ContactSolver&, EPSolver&, Real, Real>(),
            "contact_solver"_a, "elasto_plastic_solver"_a, "tolerance"_a = 1e-10,
            "relaxation"_a = 0.3, py::keep_alive<1, 2>(), py::keep_alive<1, 3>())
       .def(
           "solve",
           [](EPICSolver& solver, Real pressure) {
             return solver.solve(std::vector<Real>{pressure});
           },
           "normal_pressure"_a,
           py::call_guard<py::scoped_ostream_redirect,
                          py::scoped_estream_redirect>(),
           "Solves the EP contact with a relaxed fixed-point scheme. Adjust "
           "the relaxation parameter to help convergence.")
       .def(
           "acceleratedSolve",
           [](EPICSolver& solver, Real pressure) {
             return solver.acceleratedSolve(std::vector<Real>{pressure});
           },
           "normal_pressure"_a,
           py::call_guard<py::scoped_ostream_redirect,
                          py::scoped_estream_redirect>(),
           "Solves the EP contact with an accelerated fixed-point scheme. May "
           "not converge!");
 }
 
 }  // namespace wrap
 
 }  // namespace tamaas
diff --git a/python/wrap/surface.cpp b/python/wrap/surface.cpp
index 07ec191..2f8a0f4 100644
--- a/python/wrap/surface.cpp
+++ b/python/wrap/surface.cpp
@@ -1,177 +1,178 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "isopowerlaw.hh"
 #include "regularized_powerlaw.hh"
 #include "surface_generator_filter.hh"
 #include "surface_generator_random_phase.hh"
 #include "wrap.hh"
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 namespace wrap {
 
 using namespace py::literals;
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 class PyFilter : public Filter<dim> {
 public:
   using Filter<dim>::Filter;
 
   // Overriding pure virtual functions
   void
   computeFilter(GridHermitian<Real, dim>& filter_coefficients) const override {
     // NOLINTNEXTLINE(readability-else-after-return)
     PYBIND11_OVERLOAD_PURE(void, Filter<dim>, computeFilter,
                            filter_coefficients);
   }
 };
 
 template <UInt dim>
 void wrapFilter(py::module& mod) {
   auto name = makeDimensionName("Filter", dim);
   py::class_<Filter<dim>, std::shared_ptr<Filter<dim>>, PyFilter<dim>>(
       mod, name.c_str(), "Mother class for Fourier filter objects")
       .def(py::init<>())
       .def("computeFilter",
            (void (Filter<dim>::*)(GridHermitian<Real, dim>&) const) &
                Filter<dim>::computeFilter,
            "Compute the Fourier coefficient of the surface");
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void wrapIsopowerlaw(py::module& mod) {
   std::string name = makeDimensionName("Isopowerlaw", dim);
   py::class_<Isopowerlaw<dim>, Filter<dim>, std::shared_ptr<Isopowerlaw<dim>>>(
       mod, name.c_str(), "Isotropic powerlaw spectrum with a rolloff plateau")
       .def(py::init<>())
       .def_property("q0", &Isopowerlaw<dim>::getQ0, &Isopowerlaw<dim>::setQ0,
                     "Long wavelength cutoff")
       .def_property("q1", &Isopowerlaw<dim>::getQ1, &Isopowerlaw<dim>::setQ1,
                     "Rolloff wavelength")
       .def_property("q2", &Isopowerlaw<dim>::getQ2, &Isopowerlaw<dim>::setQ2,
                     "Short wavelength cutoff")
       .def_property("hurst", &Isopowerlaw<dim>::getHurst,
                     &Isopowerlaw<dim>::setHurst, "Hurst exponent")
       .def("rmsHeights", &Isopowerlaw<dim>::rmsHeights,
            "Theoretical RMS of heights")
       .def("moments", &Isopowerlaw<dim>::moments,
            "Theoretical first 3 moments of spectrum")
       .def("alpha", &Isopowerlaw<dim>::alpha, "Nayak's bandwidth parameter")
       .def("rmsSlopes", &Isopowerlaw<dim>::rmsSlopes,
            "Theoretical RMS of slopes");
 
   name = makeDimensionName("RegularizedPowerlaw", dim);
   py::class_<RegularizedPowerlaw<dim>, Filter<dim>,
              std::shared_ptr<RegularizedPowerlaw<dim>>>(
       mod, name.c_str(),
       "Isotropic regularized powerlaw with a plateau extending to the size of "
       "the system")
       .def(py::init<>())
       .def_property("q1", &RegularizedPowerlaw<dim>::getQ1,
                     &RegularizedPowerlaw<dim>::setQ1, "Rolloff wavelength")
       .def_property("q2", &RegularizedPowerlaw<dim>::getQ2,
                     &RegularizedPowerlaw<dim>::setQ2, "Short wavelength cutoff")
       .def_property("hurst", &RegularizedPowerlaw<dim>::getHurst,
                     &RegularizedPowerlaw<dim>::setHurst, "Hurst exponent");
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void wrapSurfaceGenerators(py::module& mod) {
   std::string generator_name = makeDimensionName("SurfaceGenerator", dim);
   py::class_<SurfaceGenerator<dim>>(mod, generator_name.c_str())
       .def("buildSurface", &SurfaceGenerator<dim>::buildSurface,
            py::return_value_policy::reference_internal,
            "Generate a surface and return a reference to it")
       .def("setSizes",
            [](SurfaceGenerator<dim>& m, std::array<UInt, dim> s) {
              TAMAAS_DEPRECATE("setSizes()", "the shape property");
              m.setSizes(std::move(s));
            })
       .def("setRandomSeed",
            [](SurfaceGenerator<dim>& m, long s) {
              TAMAAS_DEPRECATE("setRandomSeed()", "the random_seed property");
              m.setRandomSeed(s);
            })
 
       .def_property("random_seed", &SurfaceGenerator<dim>::getRandomSeed,
                     &SurfaceGenerator<dim>::setRandomSeed,
                     "Random generator seed")
       .def_property("shape", &SurfaceGenerator<dim>::getSizes,
                     py::overload_cast<std::array<UInt, dim>>(
                         &SurfaceGenerator<dim>::setSizes),
                     "Global shape of surfaces");
 
   std::string filter_name = makeDimensionName("SurfaceGeneratorFilter", dim);
   py::class_<SurfaceGeneratorFilter<dim>, SurfaceGenerator<dim>>(
       mod, filter_name.c_str(),
       "Generates a rough surface with Gaussian noise in the PSD")
       .def(py::init<>(), "Default constructor")
       .def(py::init<std::array<UInt, dim>>(),
            "Initialize with global surface shape")
 
       .def("setFilter",
            [](SurfaceGeneratorFilter<dim>& m, std::shared_ptr<Filter<dim>> s) {
              TAMAAS_DEPRECATE("setFilter()", "the spectrum property");
              m.setSpectrum(std::move(s));
            },
            "Set PSD filter", "filter"_a)
       .def("setSpectrum",
            [](SurfaceGeneratorFilter<dim>& m, std::shared_ptr<Filter<dim>> s) {
              TAMAAS_DEPRECATE("setSpectrum()", "the spectrum property");
              m.setSpectrum(std::move(s));
            },
            "Set PSD filter", "filter"_a)
 
       .def_property("spectrum", &SurfaceGeneratorFilter<dim>::getSpectrum,
                     &SurfaceGeneratorFilter<dim>::setSpectrum,
                     "Power spectrum object");
 
   std::string random_name =
       makeDimensionName("SurfaceGeneratorRandomPhase", dim);
   py::class_<SurfaceGeneratorRandomPhase<dim>, SurfaceGeneratorFilter<dim>>(
       mod, random_name.c_str(),
       "Generates a rough surface with uniformly distributed phases and exact "
       "prescribed PSD")
       .def(py::init<>(), "Default constructor")
       .def(py::init<std::array<UInt, dim>>(),
            "Initialize with global surface shape");
 }
 
 /* -------------------------------------------------------------------------- */
 void wrapSurface(py::module& mod) {
   wrapFilter<1>(mod);
   wrapFilter<2>(mod);
   wrapIsopowerlaw<1>(mod);
   wrapIsopowerlaw<2>(mod);
   wrapSurfaceGenerators<1>(mod);
   wrapSurfaceGenerators<2>(mod);
 }
 
 }  // namespace wrap
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/python/wrap/test_features.cpp b/python/wrap/test_features.cpp
index 331a581..7fc83fc 100644
--- a/python/wrap/test_features.cpp
+++ b/python/wrap/test_features.cpp
@@ -1,109 +1,110 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "boussinesq.hh"
 #include "isotropic_hardening.hh"
 #include "kelvin.hh"
 #include "mindlin.hh"
 #include "model.hh"
 #include "model_type.hh"
 #include "volume_potential.hh"
 #include "wrap.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace wrap {
 
 using namespace py::literals;
 
 template <template <model_type, UInt> class KOp, model_type type,
           UInt tensor_order>
 void wrapKOp(const std::string& basename, py::module& mod) {
   constexpr UInt dim = model_type_traits<type>::dimension;
   std::stringstream str;
   str << basename << tensor_order;
   py::class_<KOp<type, tensor_order>>(mod, str.str().c_str())
       .def(py::init<Model*>())
       .def("apply",
            [](const KOp<type, tensor_order>& engine, Grid<Real, dim>& in,
               Grid<Real, dim>& out) { engine.apply(in, out); });
 }
 
 template <model_type type>
 void wrapIsotropicHardening(py::module& mod) {
   constexpr UInt dim = model_type_traits<type>::dimension;
   py::class_<IsotropicHardening<type>>(mod, "IsotropicHardening")
       .def(py::init<Model*, Real, Real>())
       .def_property("h", &IsotropicHardening<type>::getHardeningModulus,
                     &IsotropicHardening<type>::setHardeningModulus)
       .def_property("sigma_0", &IsotropicHardening<type>::getYieldStress,
                     &IsotropicHardening<type>::setYieldStress)
       .def("computeStress",
            [](IsotropicHardening<type>& iso, Grid<Real, dim>& stress,
               const Grid<Real, dim>& strain,
               const Grid<Real, dim>& strain_increment) {
              iso.template computeStress<false>(stress, strain,
                                                strain_increment);
            })
       .def("computeStressUpdate",
            [](IsotropicHardening<type>& iso, Grid<Real, dim>& stress,
               const Grid<Real, dim>& strain,
               const Grid<Real, dim>& strain_increment) {
              iso.template computeStress<true>(stress, strain, strain_increment);
            })
       .def("computePlasticIncrement",
            [](IsotropicHardening<type>& iso, Grid<Real, dim>& stress,
               const Grid<Real, dim>& strain,
               const Grid<Real, dim>& strain_increment) {
              iso.template computePlasticIncrement<false>(stress, strain,
                                                          strain_increment);
            })
       .def("computePlasticIncrementUpdate",
            [](IsotropicHardening<type>& iso, Grid<Real, dim>& stress,
               const Grid<Real, dim>& strain,
               const Grid<Real, dim>& strain_increment) {
              iso.template computePlasticIncrement<true>(stress, strain,
                                                         strain_increment);
            });
   // .def("getPlasticStrain", &IsotropicHardening<type>::getPlasticStrain);
 }
 
 /// Wrap temporary features for testing
 void wrapTestFeatures(py::module& mod) {
   auto test_module = mod.def_submodule("_test_features");
   test_module.doc() =
       "Module for testing new features.\n"
       "DISCLAIMER: this API is subject to frequent and unannounced changes "
       "and should **not** be relied upon!";
   // wrapKOp<Kelvin, model_type::volume_2d, 2>("Kelvin_", test_module);
   // wrapKOp<Kelvin, model_type::volume_2d, 3>("Kelvin_", test_module);
   // wrapKOp<Kelvin, model_type::volume_2d, 4>("Kelvin_", test_module);
   // wrapKOp<Mindlin, model_type::volume_2d, 3>("Mindlin_", test_module);
   // wrapKOp<Mindlin, model_type::volume_2d, 4>("Mindlin_", test_module);
   // wrapKOp<Boussinesq, model_type::volume_2d, 0>("Boussinesq_", test_module);
   // wrapKOp<Boussinesq, model_type::volume_2d, 1>("Boussinesq_", test_module);
 
   wrapIsotropicHardening<model_type::volume_2d>(test_module);
 }
 }  // namespace wrap
 
 }  // namespace tamaas
diff --git a/src/SConscript b/src/SConscript
index 2c4d81e..54a5edd 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -1,144 +1,145 @@
 # -*- mode:python; coding: utf-8 -*-
 # vim: set ft=python:
 #
 # Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+# Copyright (©) 2020-2022 Lucas Frérot
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from SCons.Script import Import, Export
 
 
 def prepend(env, path, list):
     return [env.File(x, path) for x in list]
 
 
 Import('main_env')
 env = main_env.Clone()
 env.AddMethod(prepend, 'PrependDir')
 
 # Core
 core_list = """
 fft_engine.cpp
 grid.cpp
 grid_hermitian.cpp
 statistics.cpp
 tamaas.cpp
 loop.cpp
 computes.cpp
 logger.cpp
 mpi_interface.cpp
 """.split()
 core_list = env.PrependDir('core', core_list)
 
 if env['use_fftw']:
     core_list += ['core/fftw/fftw_engine.cpp']
 
     if env['use_mpi']:
         core_list += ['core/fftw/mpi/fftw_mpi_engine.cpp']
 
 if env['use_cuda']:
     core_list += ['core/cuda/cufft_engine.cpp']
 
 info_file = env.Substfile('tamaas_info.cpp', 'tamaas_info.cpp.in')
 env.Depends(info_file, Value(env.subst(env['SUBST_DICT'].values())))
 core_list.append(info_file)
 
 # Lib roughcontact
 generator_list = """
 surface_generator.cpp
 surface_generator_filter.cpp
 surface_generator_random_phase.cpp
 isopowerlaw.cpp
 regularized_powerlaw.cpp
 """.split()
 generator_list = env.PrependDir('surface', generator_list)
 
 # Lib PERCOLATION
 percolation_list = """
 flood_fill.cpp
 """.split()
 percolation_list = env.PrependDir('percolation', percolation_list)
 
 # Model
 model_list = """
 model.cpp
 model_factory.cpp
 model_type.cpp
 model_template.cpp
 integral_operator.cpp
 be_engine.cpp
 westergaard.cpp
 elastic_functional.cpp
 meta_functional.cpp
 adhesion_functional.cpp
 volume_potential.cpp
 kelvin.cpp
 mindlin.cpp
 boussinesq.cpp
 hooke.cpp
 
 elasto_plastic/isotropic_hardening.cpp
 elasto_plastic/residual.cpp
 
 integration/element.cpp
 """.split()
 model_list = env.PrependDir('model', model_list)
 
 # Solvers
 solvers_list = """
 contact_solver.cpp
 polonsky_keer_rey.cpp
 kato_saturated.cpp
 kato.cpp
 beck_teboulle.cpp
 condat.cpp
 polonsky_keer_tan.cpp
 ep_solver.cpp
 dfsane_solver.cpp
 epic.cpp
 """.split()
 solvers_list = env.PrependDir('solvers', solvers_list)
 
 # Assembling total list
 rough_contact_list = \
   core_list + generator_list + percolation_list + model_list + solvers_list
 
 # Adding extra warnings for Tamaas base lib
 env.AppendUnique(CXXFLAGS=['-Wextra'])
 
 # Allowing libTamaas.so to find libs in the same directory
 env.AppendUnique(RPATH=["'$$$$ORIGIN'"])
 
 # Build static library for packaging
 if env['build_static_lib']:
     env.AppendUnique(CXXFLAGS='-fPIC')
     libTamaas = env.StaticLibrary('Tamaas', rough_contact_list)
 # Build shared library (default)
 else:
     libTamaas = env.SharedLibrary('Tamaas', rough_contact_list,
                                   SHLIBVERSION=env['version'])
 
 
 # Specify install target to install lib
 lib_prefix = env.Dir('lib', env['prefix'])
 lib_install = env.InstallVersionedLib(target=lib_prefix,
                                       source=libTamaas)
 
 # Defining alias targets
 main_env.Alias('build-cpp', libTamaas)
 main_env.Alias('install-lib', lib_install)
 
 # Export target for use in python builds
 Export('libTamaas')
diff --git a/src/core/array.hh b/src/core/array.hh
index 28582c4..c563bb8 100644
--- a/src/core/array.hh
+++ b/src/core/array.hh
@@ -1,171 +1,172 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ARRAY_HH
 #define ARRAY_HH
 /* -------------------------------------------------------------------------- */
 #include "logger.hh"
 #include "tamaas.hh"
 #include <memory>
 #include <thrust/copy.h>
 #include <thrust/fill.h>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Generic storage class with wrapping capacities
 template <typename T>
 struct Array final {
   /// Default
   Array() = default;
   /// Empty array of given size
   Array(UInt size) : Array() { this->resize(size); }
   /// Copy constructor (deep)
   Array(const Array& v) : Array() {
     this->resize(v._size);
     thrust::copy_n(v._data, v._size, this->_data);
   }
   /// Move constructor (transfers data ownership)
   Array(Array&& v) noexcept : Array() {
     _data = std::exchange(v._data, nullptr);
     _size = std::exchange(v._size, 0);
     _reserved = std::exchange(v._reserved, 0);
     wrapped = std::exchange(v.wrapped, false);
   }
   /// Wrap array on data
   Array(T* data, UInt size) : Array() { this->wrapMemory(data, size); }
   /// Destructor
   ~Array() {
     if (not wrapped)
       _alloc.deallocate(_data, _reserved);
   }
 
   /// Copy operator
   Array& operator=(const Array& v) {
     this->wrapped = false;
     if (v.size() != this->size())
       this->resize(v.size());
     thrust::copy_n(v._data, _size, _data);
     return *this;
   }
 
   /// Move operator
   Array& operator=(Array&& v) noexcept {
     if (this != &v) {
       if (not wrapped)
         _alloc.deallocate(_data, _reserved);
       _data = std::exchange(v._data, nullptr);
       _size = std::exchange(v._size, 0);
       _reserved = std::exchange(v._reserved, 0);
       wrapped = std::exchange(v.wrapped, false);
     }
     return *this;
   }
 
   void wrap(Array& other) { this->wrapMemory(other._data, other._size); }
 
   void wrap(const Array& other) { this->wrapMemory(other._data, other._size); }
 
   /// Wrap a memory pointer
   void wrapMemory(T* data, UInt size) {
     _data = data;
     _size = size;
     wrapped = true;
     _reserved = 0;
   }
 
   /// Assign a sigle value to the array
   void assign(UInt size, const T& value) {
     this->resize(size);
     thrust::fill(_data, _data + size, value);
   }
 
   void setWrapped(bool w) { wrapped = w; }
 
   /// Data pointer access (const)
   const T* data() const { return _data; }
   /// Data pointer access (non-const)
   T* data() { return _data; }
   /// Data pointer setter
   void setData(T* new_ptr) { _data = new_ptr; }
   /// Resize array
   void resize(UInt size) {
     if (wrapped)
       TAMAAS_EXCEPTION("cannot resize wrapped array");
 
     // Erase array
     if (size == 0) {
       _alloc.deallocate(_data, _reserved);
       _data = nullptr;
       _size = 0;
       _reserved = 0;
       return;
     }
 
     // Do nothing
     if (size == this->_size)
       return;
 
     // Allocate new data
     _alloc.deallocate(_data, _reserved);
 
     _data = _alloc.allocate(size);
     _size = size;
     _reserved = size;
   }
   /// Reserve storage space
   void reserve(UInt size) {
     if (_reserved >= size)
       return;
 
     auto new_data = _alloc.allocate(size);
     if (new_data != _data) {
       thrust::copy_n(_data, _size, new_data);
       _alloc.deallocate(_data, _reserved);
       _data = new_data;
       _reserved = size;
     }
   }
   /// Access operator
   inline T& operator[](UInt i) {
     TAMAAS_ASSERT(i < _size, "memory overflow");
     return _data[i];
   }
   /// Access operator (const)
   inline const T& operator[](UInt i) const {
     TAMAAS_ASSERT(i < _size, "memory overflow");
     return _data[i];
   }
   /// Get size of array
   inline UInt size() const { return _size; }
 
 private:
   T* _data = nullptr;
   UInt _size = 0;
   std::size_t _reserved = 0;
   bool wrapped = false;
   Allocator<T> _alloc;
 };
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif /* ARRAY_HH */
diff --git a/src/core/computes.cpp b/src/core/computes.cpp
index 5d91878..2109903 100644
--- a/src/core/computes.cpp
+++ b/src/core/computes.cpp
@@ -1,38 +1,39 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "computes.hh"
 
 namespace tamaas {
 void eigenvalues(model_type type, GridBase<Real>& eigs,
                  const GridBase<Real>& field) {
   applyCompute<compute::Eigenvalues>(type, eigs, field);
 }
 void vonMises(model_type type, GridBase<Real>& eigs,
               const GridBase<Real>& field) {
   applyCompute<compute::VonMises>(type, eigs, field);
 }
 void deviatoric(model_type type, GridBase<Real>& dev,
                 const GridBase<Real>& field) {
   applyCompute<compute::Deviatoric>(type, dev, field);
 }
 
 }  // namespace tamaas
diff --git a/src/core/computes.hh b/src/core/computes.hh
index a0c4763..2d8c55b 100644
--- a/src/core/computes.hh
+++ b/src/core/computes.hh
@@ -1,106 +1,107 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef EIGENVALUES_HH
 #define EIGENVALUES_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "loop.hh"
 #include "model_type.hh"
 #include "ranges.hh"
 #include "static_types.hh"
 #include <boost/preprocessor/seq.hpp>
 
 namespace tamaas {
 
 namespace compute {
 /// Compute eigenvalues of a symmetric matrix field
 struct Eigenvalues {
   template <UInt dim>
   static void call(Grid<Real, dim>& eigs, const Grid<Real, dim>& field) {
     Loop::loop([] CUDA_LAMBDA(
                    VectorProxy<Real, dim> eig,
                    SymMatrixProxy<const Real, dim> f) { eig = eigenvalues(f); },
                range<VectorProxy<Real, dim>>(eigs),
                range<SymMatrixProxy<const Real, dim>>(field));
   }
 };
 
 /// Compute von Mises stress on a tensor field
 struct VonMises {
   template <UInt dim>
   static void call(Grid<Real, dim>& vm, const Grid<Real, dim>& stress) {
     Loop::loop(
         [] CUDA_LAMBDA(Real & vm, SymMatrixProxy<const Real, dim> sigma) {
           SymMatrix<Real, dim> dev;
           dev.deviatoric(sigma, 3);
           vm = std::sqrt(1.5) * dev.l2norm();
         },
         vm, range<SymMatrixProxy<const Real, dim>>(stress));
   }
 };
 
 /// Compute deviatoric of tensor field
 struct Deviatoric {
   template <UInt dim>
   static void call(Grid<Real, dim>& dev, const Grid<Real, dim>& field) {
     Loop::loop(
         [] CUDA_LAMBDA(SymMatrixProxy<Real, dim> s,
                        SymMatrixProxy<const Real, dim> sigma) {
           s.deviatoric(sigma, 3);
         },
         range<SymMatrixProxy<Real, dim>>(dev),
         range<SymMatrixProxy<const Real, dim>>(field));
   }
 };
 }  // namespace compute
 
 template <typename Compute>
 void applyCompute(model_type type, GridBase<Real>& result,
                   const GridBase<Real>& field) {
 #define APPLY_CASE(_, __, type)                                                \
   case type: {                                                                 \
     constexpr UInt dim = model_type_traits<type>::dimension;                   \
     const auto& f = dynamic_cast<const Grid<Real, dim>&>(field);               \
     auto& e = dynamic_cast<Grid<Real, dim>&>(result);                          \
     Compute::template call<dim>(e, f);                                         \
     break;                                                                     \
   }
 
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(APPLY_CASE, ~, (model_type::volume_2d));
   default:
     TAMAAS_EXCEPTION("Model type "
                      << type << " not yet suported for field computation");
   }
 #undef APPLY_CASE
 }
 
 void eigenvalues(model_type type, GridBase<Real>& eigs,
                  const GridBase<Real>& field);
 void vonMises(model_type type, GridBase<Real>& eigs,
               const GridBase<Real>& field);
 void deviatoric(model_type type, GridBase<Real>& dev,
                 const GridBase<Real>& field);
 
 }  // namespace tamaas
 
 #endif /* EIGENVALUES_HH */
diff --git a/src/core/cuda/cufft_engine.cpp b/src/core/cuda/cufft_engine.cpp
index 1cce1e9..c9fe226 100644
--- a/src/core/cuda/cufft_engine.cpp
+++ b/src/core/cuda/cufft_engine.cpp
@@ -1,58 +1,59 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "cufft_engine.hh"
 #include <algorithm>
 #include <functional>
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 CuFFTEngine::plan_t& CuFFTEngine::getPlans(key_t key) {
   if (plans.find(key) != plans.end())
     return plans[key];
 
   const int rank = key.size() - 3;  // dimension of fft
   const auto components = key[rank];
 
   std::vector<int> n(rank);  // size of individual fft
   std::copy_n(key.begin(), rank, n.begin());
 
   const int howmany = components;  // how many fft to compute
   const int idist = 1,
             odist = 1;  // components are next to each other in memory
   const int istride = key[rank + 1] * components,
             ostride = key[rank + 2] * components;
   int *inembed = nullptr, *onembed = nullptr;  // row major
 
   plan_t cufft_plans;
   cufftResult forward_res =
       cufftPlanMany(&cufft_plans.first._plan, rank, n.data(), inembed, istride,
                     idist, onembed, ostride, odist, CUFFT_D2Z, howmany);
   cufftResult backward_res =
       cufftPlanMany(&cufft_plans.second._plan, rank, n.data(), onembed, ostride,
                     odist, inembed, istride, idist, CUFFT_Z2D, howmany);
 
   plans[key] = std::move(cufft_plans);
   return plans[key];
 }
 
 }  // namespace tamaas
diff --git a/src/core/cuda/cufft_engine.hh b/src/core/cuda/cufft_engine.hh
index 0d05f2f..f2ec9e0 100644
--- a/src/core/cuda/cufft_engine.hh
+++ b/src/core/cuda/cufft_engine.hh
@@ -1,133 +1,134 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef CUFFT_ENGINE_H
 #define CUFFT_ENGINE_H
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include <cufft.h>
 /* -------------------------------------------------------------------------- */
 
 namespace cufft {
 struct plan {
   cufftHandle _plan;
 
   plan() = default;
 
   plan(plan&& o) noexcept : _plan(o._plan) {}
 
   plan& operator=(plan&& o) noexcept {
     _plan = o._plan;
     return *this;
   }
 
   /// Destroy plan
   ~plan() noexcept { cufftDestroy(_plan); }
 
   /// For seamless use with fftw api
   operator cufftHandle() const { return _plan; }
 };
 }  // namespace cufft
 
 namespace tamaas {
 
 class CuFFTEngine : public FFTEngine {
 private:
   using plan_t = std::pair<cufft::plan, cufft::plan>;
 
   /// Perform forward (R2C) transform
   template <UInt dim>
   void forwardImpl(const Grid<Real, dim>& real,
                    GridHermitian<Real, dim>& spectral);
   /// Perform backward (C2R) transform
   template <UInt dim>
   void backwardImpl(Grid<Real, dim>& real,
                     const GridHermitian<Real, dim>& spectral);
   /// Return the plans pair for a given transform signature
   plan_t& getPlans(key_t key);
 
 public:
   /// Initialize with flags
   explicit CuFFTEngine(unsigned int flags = FFTW_ESTIMATE) noexcept
       : _flags(flags), plans() {}
 
   void forward(const Grid<Real, 1>& real,
                GridHermitian<Real, 1>& spectral) override {
     forwardImpl(real, spectral);
   }
 
   void forward(const Grid<Real, 2>& real,
                GridHermitian<Real, 2>& spectral) override {
     forwardImpl(real, spectral);
   }
 
   void backward(Grid<Real, 1>& real,
                 GridHermitian<Real, 1>& spectral) override {
     backwardImpl(real, spectral);
   }
 
   void backward(Grid<Real, 2>& real,
                 GridHermitian<Real, 2>& spectral) override {
     backwardImpl(real, spectral);
   }
 
   unsigned int flags() const { return _flags; }
 
   /// Cast to FFTW complex type
   static auto cast(Complex* data) {
     return reinterpret_cast<cufftDoubleComplex*>(data);
   }
   static auto cast(const Complex* data) {
     return const_cast<cufftDoubleComplex*>(
         reinterpret_cast<const cufftDoubleComplex*>(data));
   }
 
 protected:
   unsigned int _flags;            ///< FFTW flags
   std::map<key_t, plan_t> plans;  ///< plans corresponding to signatures
 };
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void CuFFTEngine::forwardImpl(const Grid<Real, dim>& real,
                               GridHermitian<Real, dim>& spectral) {
   auto& plans = getPlans(make_key(real, spectral));
   if (cufftExecD2Z(plans.first, const_cast<Real*>(real.getInternalData()),
                    cast(spectral.getInternalData())) != CUFFT_SUCCESS)
     TAMAAS_EXCEPTION("Forward transform fail");
   cudaDeviceSynchronize();
 }
 
 template <UInt dim>
 void CuFFTEngine::backwardImpl(Grid<Real, dim>& real,
                                const GridHermitian<Real, dim>& spectral) {
   auto& plans = getPlans(make_key(real, spectral));
   if (cufftExecZ2D(plans.second, cast(spectral.getInternalData()),
                    real.getInternalData()) != CUFFT_SUCCESS)
     TAMAAS_EXCEPTION("Backward transform fail");
   cudaDeviceSynchronize();
 
   // Normalize
   real *= (1. / real.getNbPoints());
 }
 
 }  // namespace tamaas
 #endif
diff --git a/src/core/cuda/unified_allocator.hh b/src/core/cuda/unified_allocator.hh
index e82a5a4..7630e9d 100644
--- a/src/core/cuda/unified_allocator.hh
+++ b/src/core/cuda/unified_allocator.hh
@@ -1,50 +1,51 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef UNIFIED_ALLOCATOR_HH
 #define UNIFIED_ALLOCATOR_HH
 /* -------------------------------------------------------------------------- */
 #include <cuda_runtime_api.h>
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Class allocating [unified
 /// memory](http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY.html#group__CUDART__MEMORY_1gd228014f19cc0975ebe3e0dd2af6dd1b)
 template <typename T>
 struct UnifiedAllocator {
   /// Allocate memory
   static T* allocate(std::size_t n) {
     T* p = nullptr;
     cudaMallocManaged(&p, n * sizeof(T));
     return p;
   }
 
   /// Free memory
   static void deallocate(T* p, __attribute__((unused)) std::size_t n) {
     cudaFree(p);
   }
 };
 
 }  // namespace tamaas
 
 #endif  // UNIFIED_ALLOCATOR_HH
diff --git a/src/core/fft_engine.cpp b/src/core/fft_engine.cpp
index 264f0d2..26abb75 100644
--- a/src/core/fft_engine.cpp
+++ b/src/core/fft_engine.cpp
@@ -1,58 +1,59 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 
 #if TAMAAS_USE_CUDA
 #include "cuda/cufft_engine.hh"
 #else
 #include "fftw/fftw_engine.hh"
 #ifdef TAMAAS_USE_MPI
 #include "fftw/mpi/fftw_mpi_engine.hh"
 #include "mpi_interface.hh"
 #endif
 #endif
 
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 std::unique_ptr<FFTEngine> FFTEngine::makeEngine(unsigned int flags) {
 #define inst(x)                                                                \
   do {                                                                         \
     Logger().get(LogLevel::debug) << TAMAAS_DEBUG_MSG("[" #x "] Init");        \
     return std::make_unique<x>(flags);                                         \
   } while (0)
 
 #ifdef TAMAAS_USE_MPI
   if (mpi::size() != 1)
     inst(FFTWMPIEngine);
   else
     inst(FFTWEngine);
 #elif TAMAAS_USE_CUDA
   inst(CuFFTEngine);
 #else
   inst(FFTWEngine);
 #endif
 
 #undef inst
 }
 
 }  // namespace tamaas
diff --git a/src/core/fft_engine.hh b/src/core/fft_engine.hh
index e01b87b..150eda8 100644
--- a/src/core/fft_engine.hh
+++ b/src/core/fft_engine.hh
@@ -1,135 +1,136 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFT_ENGINE_H
 #define FFT_ENGINE_H
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_base.hh"
 #include "grid_hermitian.hh"
 #include "partitioner.hh"
 #include <algorithm>
 #include <array>
 #include <map>
 #include <memory>
 #include <string>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class FFTEngine {
 protected:
   using key_t = std::basic_string<UInt>;
 
 public:
   virtual ~FFTEngine() noexcept = default;
 
   /// Execute a forward plan on real and spectral 1D
   virtual void forward(const Grid<Real, 1>& real,
                        GridHermitian<Real, 1>& spectral) = 0;
   /// Execute a forward plan on real and spectral 2D
   virtual void forward(const Grid<Real, 2>& real,
                        GridHermitian<Real, 2>& spectral) = 0;
   /// Execute a backward plan on real and spectral 1D
   virtual void backward(Grid<Real, 1>& real,
                         GridHermitian<Real, 1>& spectral) = 0;
   /// Execute a backward plan on real and spectral 2D
   virtual void backward(Grid<Real, 2>& real,
                         GridHermitian<Real, 2>& spectral) = 0;
 
   /// Fill a grid with wavevector values in appropriate ordering
   template <typename T, UInt dim, bool hermitian>
   static Grid<T, dim> computeFrequencies(const std::array<UInt, dim>& sizes);
 
   /// Instanciate an appropriate FFTEngine subclass
   static std::unique_ptr<FFTEngine>
   makeEngine(unsigned int flags = FFTW_ESTIMATE);
 
 protected:
   /// Make a transform signature from a pair of grids
   template <UInt dim>
   static key_t make_key(const Grid<Real, dim>& real,
                         const GridHermitian<Real, dim>& spectral);
 };
 
 template <UInt dim>
 FFTEngine::key_t FFTEngine::make_key(const Grid<Real, dim>& real,
                                      const GridHermitian<Real, dim>& spectral) {
   if (real.getNbComponents() != spectral.getNbComponents())
     TAMAAS_EXCEPTION("Components do not match");
 
   auto hermitian_dims =
       GridHermitian<Real, dim>::hermitianDimensions(real.sizes());
   if (not std::equal(hermitian_dims.begin(), hermitian_dims.end(),
                      spectral.sizes().begin()))
     TAMAAS_EXCEPTION("Spectral grid does not have hermitian size");
 
   // Reserve space for dimensions + components + both last strides
   key_t key(real.getDimension() + 3, 0);
   std::copy_n(real.sizes().begin(), dim, key.begin());
   key[dim] = real.getNbComponents();
   key[dim + 1] = real.getStrides().back();
   key[dim + 2] = spectral.getStrides().back();
   return key;
 }
 
 template <typename T, UInt dim, bool hermitian>
 Grid<T, dim>
 FFTEngine::computeFrequencies(const std::array<UInt, dim>& local_sizes) {
   // If hermitian is true, we suppose the dimensions of freq are
   // reduced based on hermitian symetry and that it has dim components
 
   Grid<T, dim> freq(local_sizes, dim);
   constexpr Int dmax = dim - static_cast<Int>(hermitian);
 
   // For MPI
   const auto& n = Partitioner<dim>::global_size(local_sizes);
   const auto offset = Partitioner<dim>::local_offset(freq) / dim;
 
 #pragma omp parallel for  // to get rid of a compilation warning from nvcc
   for (UInt i = 0; i < freq.getNbPoints(); ++i) {
     UInt index = i + offset;
     VectorProxy<T, dim> wavevector(freq(i * freq.getNbComponents()));
     std::array<UInt, dim> tuple{{0}};
     /// Computing tuple from index
     for (Int d = dim - 1; d >= 0; d--) {
       tuple[d] = index % n[d];
       index -= tuple[d];
       index /= n[d];
     }
 
     if (hermitian)
       wavevector(dim - 1) = tuple[dim - 1];
 
     for (Int d = 0; d < dmax; d++) {
       // Type conversion
       T td = tuple[d];
       T nd = n[d];
       T q = (tuple[d] < n[d] / 2) ? td : td - nd;
       wavevector(d) = q;
     }
   }
 
   return freq;
 }
 
 }  // namespace tamaas
 
 #endif
diff --git a/src/core/fftw/fftw_allocator.hh b/src/core/fftw/fftw_allocator.hh
index 3d61b91..f0eab15 100644
--- a/src/core/fftw/fftw_allocator.hh
+++ b/src/core/fftw/fftw_allocator.hh
@@ -1,51 +1,52 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_ALLOCATOR_HH
 #define FFTW_ALLOCATOR_HH
 /* -------------------------------------------------------------------------- */
 #include <fftw3.h>
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Class allocating
 /// [SIMD](http://www.fftw.org/fftw3_doc/SIMD-alignment-and-fftw_005fmalloc.html#SIMD-alignment-and-fftw_005fmalloc)
 /// aligned memory
 template <typename T>
 struct FFTWAllocator {
   /// Allocate memory
   static T* allocate(std::size_t n) noexcept {
     T* p = nullptr;
     p = (T*)fftw_malloc(sizeof(T) * n);
     return p;
   }
 
   /// Free memory
   static void deallocate(T* p, __attribute__((unused)) std::size_t n) noexcept {
     fftw_free(p);
   }
 };
 
 }  // namespace tamaas
 
 #endif  // FFTW_ALLOCATOR_HH
diff --git a/src/core/fftw/fftw_engine.cpp b/src/core/fftw/fftw_engine.cpp
index 77006de..9b78b5d 100644
--- a/src/core/fftw/fftw_engine.cpp
+++ b/src/core/fftw/fftw_engine.cpp
@@ -1,70 +1,71 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fftw_engine.hh"
 #include <algorithm>
 #include <functional>
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 FFTWEngine::plan_t& FFTWEngine::getPlans(key_t key) {
   if (plans.find(key) != plans.end())
     return plans[key];
 
   const int rank = key.size() - 3;  // dimension of fft
   const auto components = key[rank];
 
   std::vector<int> n(rank);  // size of individual fft
   std::copy_n(key.begin(), rank, n.begin());
 
   const int howmany = components;  // how many fft to compute
   const int idist = 1,
             odist = 1;  // components are next to each other in memory
   const int istride = key[rank + 1] * components,
             ostride = key[rank + 2] * components;
   int *inembed = nullptr, *onembed = nullptr;  // row major
 
   fftw::ptr<Real> in{nullptr};
   fftw::ptr<complex_t> out{nullptr};
 
   // Flags does not contain FFTW_ESTIMATE | FFTW_UNALIGNED => allocate in & out
   if (not(_flags & FFTW_ESTIMATE and _flags & FFTW_UNALIGNED)) {
     const auto prod = [](auto&& n) {
       return std::accumulate(n.cbegin(), n.cend(), 1, std::multiplies<void>());
     };
 
     const auto hermit_n = GridHermitian<Real, 1>::hermitianDimensions(n);
     in._ptr = fftw::helper<Real>::alloc_real(prod(n) * istride);
     out._ptr = fftw::helper<Real>::alloc_complex(prod(hermit_n) * ostride);
   }
 
   fftw::plan<Real> forward{
       fftw::plan_many_forward(rank, n.data(), howmany, in, inembed, istride,
                               idist, out, onembed, ostride, odist, _flags)};
   fftw::plan<Real> backward{
       fftw::plan_many_backward(rank, n.data(), howmany, out, onembed, ostride,
                                odist, in, inembed, istride, idist, _flags)};
   plans[key] = std::make_pair(std::move(forward), std::move(backward));
   return plans[key];
 }
 
 }  // namespace detail
diff --git a/src/core/fftw/fftw_engine.hh b/src/core/fftw/fftw_engine.hh
index 8b1cecb..ef299e8 100644
--- a/src/core/fftw/fftw_engine.hh
+++ b/src/core/fftw/fftw_engine.hh
@@ -1,104 +1,105 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_ENGINE_HH
 #define FFTW_ENGINE_HH
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "fftw/interface.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class FFTWEngine : public FFTEngine {
 protected:
   using plan_t = std::pair<fftw::plan<Real>, fftw::plan<Real>>;
   using complex_t = fftw::helper<Real>::complex;
 
   /// Perform forward (R2C) transform
   template <UInt dim>
   void forwardImpl(const Grid<Real, dim>& real,
                    GridHermitian<Real, dim>& spectral);
   /// Perform backward (C2R) transform
   template <UInt dim>
   void backwardImpl(Grid<Real, dim>& real,
                     const GridHermitian<Real, dim>& spectral);
   /// Return the plans pair for a given transform signature
   plan_t& getPlans(key_t key);
 
 public:
   /// Initialize with flags
   explicit FFTWEngine(unsigned int flags = FFTW_ESTIMATE) noexcept
       : _flags(flags) {}
 
   void forward(const Grid<Real, 1>& real,
                GridHermitian<Real, 1>& spectral) override {
     forwardImpl(real, spectral);
   }
 
   void forward(const Grid<Real, 2>& real,
                GridHermitian<Real, 2>& spectral) override {
     forwardImpl(real, spectral);
   }
 
   void backward(Grid<Real, 1>& real,
                 GridHermitian<Real, 1>& spectral) override {
     backwardImpl(real, spectral);
   }
 
   void backward(Grid<Real, 2>& real,
                 GridHermitian<Real, 2>& spectral) override {
     backwardImpl(real, spectral);
   }
 
   unsigned int flags() const { return _flags; }
 
   /// Cast to FFTW complex type
   static auto cast(Complex* data) { return reinterpret_cast<complex_t*>(data); }
   static auto cast(const Complex* data) {
     return const_cast<complex_t*>(reinterpret_cast<const complex_t*>(data));
   }
 
 protected:
   unsigned int _flags;            ///< FFTW flags
   std::map<key_t, plan_t> plans;  ///< plans corresponding to signatures
 };
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void FFTWEngine::forwardImpl(const Grid<Real, dim>& real,
                              GridHermitian<Real, dim>& spectral) {
   auto& plans = getPlans(make_key(real, spectral));
   fftw::execute(plans.first, const_cast<Real*>(real.getInternalData()),
                 cast(spectral.getInternalData()));
 }
 
 template <UInt dim>
 void FFTWEngine::backwardImpl(Grid<Real, dim>& real,
                               const GridHermitian<Real, dim>& spectral) {
   auto& plans = getPlans(make_key(real, spectral));
   fftw::execute(plans.second, cast(spectral.getInternalData()),
                 real.getInternalData());
   // Normalize
   real *= (1. / real.getNbPoints());
 }
 
 }  // namespace tamaas
 #endif
diff --git a/src/core/fftw/interface.hh b/src/core/fftw/interface.hh
index 6093566..ec0062e 100644
--- a/src/core/fftw/interface.hh
+++ b/src/core/fftw/interface.hh
@@ -1,39 +1,40 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_INTERFACE_HH
 #define FFTW_INTERFACE_HH
 /* -------------------------------------------------------------------------- */
 
 #include "mpi/interface.hh"
 
 #ifdef TAMAAS_USE_FFTW
 #include "interface_impl.hh"
 namespace fftw = fftw_impl;
 #else
 namespace fftw {
 namespace mpi = fftw_impl::mpi_dummy;
 }
 
 #define FFTW_ESTIMATE 1
 #endif  // TAMAAS_USE_FFTW
 
 #endif  // FFTW_INTERFACE
diff --git a/src/core/fftw/interface_impl.hh b/src/core/fftw/interface_impl.hh
index c675487..ec50e15 100644
--- a/src/core/fftw/interface_impl.hh
+++ b/src/core/fftw/interface_impl.hh
@@ -1,205 +1,206 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_INTERFACE_IMPL_HH
 #define FFTW_INTERFACE_IMPL_HH
 /* -------------------------------------------------------------------------- */
 #include <cstddef>
 #include <fftw3.h>
 #include <functional>
 #include <numeric>
 #include <utility>
 
 namespace fftw_impl {
 template <typename T>
 struct helper;
 
 template <>
 struct helper<double> {
   using complex = fftw_complex;
   using plan = fftw_plan;
 
   static auto alloc_real(std::size_t size) { return fftw_alloc_real(size); }
   static auto alloc_complex(std::size_t size) {
     return fftw_alloc_complex(size);
   }
 };
 
 template <>
 struct helper<long double> {
   using complex = fftwl_complex;
   using plan = fftwl_plan;
 
   static auto alloc_real(std::size_t size) { return fftwl_alloc_real(size); }
   static auto alloc_complex(std::size_t size) {
     return fftwl_alloc_complex(size);
   }
 };
 
 template <typename T>
 inline auto free(T* ptr) {
   fftw_free(ptr);
 }
 
 inline auto destroy(fftw_plan plan) { fftw_destroy_plan(plan); }
 inline auto destroy(fftwl_plan plan) { fftwl_destroy_plan(plan); }
 inline auto init_threads() { return fftw_init_threads(); }
 inline auto plan_with_nthreads(int nthreads) {
   return fftw_plan_with_nthreads(nthreads);
 }
 inline auto cleanup_threads() { return fftw_cleanup_threads(); }
 
 /// Holder type for fftw plans
 template <typename T>
 struct plan {
   typename helper<T>::plan _plan;
 
   /// Create from plan
   explicit plan(typename helper<T>::plan _plan = nullptr) : _plan(_plan) {}
   /// Move constructor to avoid accidental plan destruction
   plan(plan&& o) noexcept : _plan(std::exchange(o._plan, nullptr)) {}
   /// Move operator
   plan& operator=(plan&& o) noexcept {
     _plan = std::exchange(o._plan, nullptr);
     return *this;
   }
   /// Destroy plan
   ~plan() noexcept {
     if (_plan)
       fftw_impl::destroy(_plan);
   }
 
   /// For seamless use with fftw api
   operator typename helper<T>::plan() const { return _plan; }
 };
 
 /// RAII helper for fftw_free
 template <typename T>
 struct ptr {
   T* _ptr;
 
   ~ptr() noexcept {
     if (_ptr)
       fftw_impl::free(_ptr);
   }
 
   operator T*() { return _ptr; }
 };
 
 /* -------------------------------------------------------------------------- */
 
 inline auto plan_many_forward(int rank, const int* n, int howmany, double* in,
                               const int* inembed, int istride, int idist,
                               fftw_complex* out, const int* onembed,
                               int ostride, int odist, unsigned flags) {
   return fftw_plan_many_dft_r2c(rank, n, howmany, in, inembed, istride, idist,
                                 out, onembed, ostride, odist, flags);
 }
 
 inline auto plan_many_backward(int rank, const int* n, int howmany,
                                fftw_complex* in, const int* inembed,
                                int istride, int idist, double* out,
                                const int* onembed, int ostride, int odist,
                                unsigned flags) {
   return fftw_plan_many_dft_c2r(rank, n, howmany, in, inembed, istride, idist,
                                 out, onembed, ostride, odist, flags);
 }
 
 inline auto plan_1d_forward(int n, double* in, fftw_complex* out,
                             unsigned flags) {
   return fftw_plan_dft_r2c_1d(n, in, out, flags);
 }
 
 inline auto plan_1d_backward(int n, fftw_complex* in, double* out,
                              unsigned flags) {
   return fftw_plan_dft_c2r_1d(n, in, out, flags);
 }
 
 inline auto plan_2d_forward(int n0, int n1, double* in, fftw_complex* out,
                             unsigned flags) {
   return fftw_plan_dft_r2c_2d(n0, n1, in, out, flags);
 }
 
 inline auto plan_2d_backward(int n0, int n1, fftw_complex* out, double* in,
                              unsigned flags) {
   return fftw_plan_dft_c2r_2d(n0, n1, out, in, flags);
 }
 
 inline auto execute(fftw_plan plan) { fftw_execute(plan); }
 inline auto execute(fftw_plan plan, double* in, fftw_complex* out) {
   fftw_execute_dft_r2c(plan, in, out);
 }
 
 inline auto execute(fftw_plan plan, fftw_complex* in, double* out) {
   fftw_execute_dft_c2r(plan, in, out);
 }
 
 /* -------------------------------------------------------------------------- */
 
 inline auto plan_many_forward(int rank, const int* n, int howmany,
                               long double* in, const int* inembed, int istride,
                               int idist, fftwl_complex* out, const int* onembed,
                               int ostride, int odist, unsigned flags) {
   return fftwl_plan_many_dft_r2c(rank, n, howmany, in, inembed, istride, idist,
                                  out, onembed, ostride, odist, flags);
 }
 
 inline auto plan_many_backward(int rank, const int* n, int howmany,
                                fftwl_complex* in, const int* inembed,
                                int istride, int idist, long double* out,
                                const int* onembed, int ostride, int odist,
                                unsigned flags) {
   return fftwl_plan_many_dft_c2r(rank, n, howmany, in, inembed, istride, idist,
                                  out, onembed, ostride, odist, flags);
 }
 
 inline auto plan_1d_forward(int n, long double* in, fftwl_complex* out,
                             unsigned flags) {
   return fftwl_plan_dft_r2c_1d(n, in, out, flags);
 }
 
 inline auto plan_1d_backward(int n, fftwl_complex* in, long double* out,
                              unsigned flags) {
   return fftwl_plan_dft_c2r_1d(n, in, out, flags);
 }
 
 inline auto plan_2d_forward(int n0, int n1, long double* in, fftwl_complex* out,
                             unsigned flags) {
   return fftwl_plan_dft_r2c_2d(n0, n1, in, out, flags);
 }
 
 inline auto plan_2d_backward(int n0, int n1, fftwl_complex* out,
                              long double* in, unsigned flags) {
   return fftwl_plan_dft_c2r_2d(n0, n1, out, in, flags);
 }
 
 inline auto execute(fftwl_plan plan) { fftwl_execute(plan); }
 inline auto execute(fftwl_plan plan, long double* in, fftwl_complex* out) {
   fftwl_execute_dft_r2c(plan, in, out);
 }
 
 inline auto execute(fftwl_plan plan, fftwl_complex* in, long double* out) {
   fftwl_execute_dft_c2r(plan, in, out);
 }
 
 }  // namespace fftw_impl
 
 #endif  // FFTW_INTERFACE
diff --git a/src/core/fftw/mpi/fftw_mpi_engine.cpp b/src/core/fftw/mpi/fftw_mpi_engine.cpp
index cc3bb28..56bb28b 100644
--- a/src/core/fftw/mpi/fftw_mpi_engine.cpp
+++ b/src/core/fftw/mpi/fftw_mpi_engine.cpp
@@ -1,134 +1,135 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fftw/mpi/fftw_mpi_engine.hh"
 #include "fftw/interface.hh"
 #include "logger.hh"
 #include "mpi_interface.hh"
 #include "partitioner.hh"
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 auto FFTWMPIEngine::local_size(const key_t& key) {
   const auto n = [&key]() {
     std::array<UInt, 2> sizes;
     std::copy_n(key.cbegin(), 2, sizes.begin());
     sizes[1] = sizes[1] / 2 + 1;  // hermitian size
     return sizes;
   }();
 
   const auto sizes = Partitioner<2>::local_size(n);
   return std::make_pair(Partitioner<2>::alloc_size(n, key[2]),
                         std::get<0>(sizes));
 }
 
 void FFTWMPIEngine::forward(const Grid<Real, 2>& real,
                             GridHermitian<Real, 2>& spectral) {
   const auto key = make_key(real, spectral);
   auto& plans = getPlans(key);
   auto& workspace = workspaces[key];
 
   // Ensure enough space for MPI overhead
   const auto sizes = local_size(key);
   spectral.reserve(sizes.first);
 
   // Can't use iterators here because of size mistmatch in workspace
 #pragma omp parallel for collapse(3)
   for (UInt i = 0; i < real.sizes()[0]; ++i)
     for (UInt j = 0; j < real.sizes()[1]; ++j)
       for (UInt k = 0; k < real.getNbComponents(); ++k)
         workspace(i, j, k) = real(i, j, k);
 
   fftw_mpi_execute_dft_r2c(plans.first, workspace.getInternalData(),
                            cast(spectral.getInternalData()));
 }
 
 void FFTWMPIEngine::backward(Grid<Real, 2>& real,
                              GridHermitian<Real, 2>& spectral) {
   auto key = make_key(real, spectral);
   auto& plans = getPlans(key);
   auto& workspace = workspaces[key];
 
   // Ensure enough space for MPI overhead
   const auto sizes = local_size(key);
   spectral.reserve(sizes.first);
 
   fftw_mpi_execute_dft_c2r(plans.second, cast(spectral.getInternalData()),
                            workspace.getInternalData());
 
   // Can't use iterators here because of size mistmatch in worspace
 #pragma omp parallel for collapse(3)
   for (UInt i = 0; i < real.sizes()[0]; ++i)
     for (UInt j = 0; j < real.sizes()[1]; ++j)
       for (UInt k = 0; k < real.getNbComponents(); ++k)
         real(i, j, k) = workspace(i, j, k);
 
   real *= (1. / real.getGlobalNbPoints());
 }
 
 FFTWMPIEngine::key_t
 FFTWMPIEngine::make_key(const Grid<Real, 2>& real,
                         const GridHermitian<Real, 2>& spectral) {
   auto key{FFTEngine::make_key(real, spectral)};
 
   // Reduce first dimension for total size
   key.front() = mpi::allreduce<operation::plus>(key.front());
 
   return key;
 }
 
 FFTWMPIEngine::plan_t& FFTWMPIEngine::getPlans(key_t key) {
   if (plans.find(key) != plans.end())
     return plans[key];
 
   const int rank = key.size() - 3;  // dimension of fft
   const int howmany = key[rank];
 
   std::vector<std::ptrdiff_t> n(rank);  // size of individual fft
   std::copy_n(key.begin(), rank, n.begin());
 
   fftw::ptr<Real> in{nullptr};
   fftw::ptr<complex_t> out{nullptr};
 
   const auto sizes = local_size(key);
 
   workspaces.emplace(key, Grid<Real, 2>({static_cast<UInt>(sizes.second),
                                          2 * (key[1] / 2 + 1)},
                                         howmany));
 
   auto& workspace = workspaces[key];
   workspace.reserve(2 * sizes.first);
 
   out._ptr = fftw::helper<Real>::alloc_complex(sizes.first);
 
   fftw::plan<Real> forward{fftw_mpi_plan_many_dft_r2c(
       rank, n.data(), howmany, FFTW_MPI_DEFAULT_BLOCK, FFTW_MPI_DEFAULT_BLOCK,
       workspace.getInternalData(), out, mpi::comm::world(), flags())};
   fftw::plan<Real> backward{fftw_mpi_plan_many_dft_c2r(
       rank, n.data(), howmany, FFTW_MPI_DEFAULT_BLOCK, FFTW_MPI_DEFAULT_BLOCK,
       out, workspace.getInternalData(), mpi::comm::world(), flags())};
 
   plans[key] = std::make_pair(std::move(forward), std::move(backward));
   return plans[key];
 }
 
 }  // namespace tamaas
diff --git a/src/core/fftw/mpi/fftw_mpi_engine.hh b/src/core/fftw/mpi/fftw_mpi_engine.hh
index 1a3da24..6e568ef 100644
--- a/src/core/fftw/mpi/fftw_mpi_engine.hh
+++ b/src/core/fftw/mpi/fftw_mpi_engine.hh
@@ -1,68 +1,69 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_MPI_ENGINE_HH
 #define FFTW_MPI_ENGINE_HH
 /* -------------------------------------------------------------------------- */
 #include "fftw/fftw_engine.hh"
 #include "fftw/interface.hh"
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include <map>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class FFTWMPIEngine : public FFTWEngine {
 public:
   using FFTWEngine::FFTWEngine;
 
   void forward(const Grid<Real, 1>& /*real*/,
                GridHermitian<Real, 1>& /*spectral*/) override {
     TAMAAS_EXCEPTION("FFTW/MPI does not support 1D transforms");
   }
   void backward(Grid<Real, 1>& /*real*/,
                 GridHermitian<Real, 1>& /*spectral*/) override {
     TAMAAS_EXCEPTION("FFTW/MPI does not support 1D transforms");
   }
 
   /// FFTW/MPI forward (r2c) transform
   void forward(const Grid<Real, 2>& real,
                GridHermitian<Real, 2>& spectral) override;
   /// FFTW/MPI backward (c2r) transform
   void backward(Grid<Real, 2>& real,
                 GridHermitian<Real, 2>& spectral) override;
 
 protected:
   /// Make a transform signature from a pair of grids
   static key_t make_key(const Grid<Real, 2>& real,
                         const GridHermitian<Real, 2>& spectral);
   /// Return the plans pair for a given transform signature
   plan_t& getPlans(key_t key);
   /// Get FFTW local sizes from an hermitian grid
   static auto local_size(const key_t& key);
 
 protected:
   /// Buffer for real data because of FFTW/MPI layout
   std::map<key_t, Grid<Real, 2>> workspaces;
 };
 
 }  // namespace tamaas
 #endif  // FFT_MPI_ENGINE_HH
diff --git a/src/core/fftw/mpi/interface.hh b/src/core/fftw/mpi/interface.hh
index 4f1bedd..5fe727f 100644
--- a/src/core/fftw/mpi/interface.hh
+++ b/src/core/fftw/mpi/interface.hh
@@ -1,68 +1,69 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FFTW_MPI_INTERFACE_HH
 #define FFTW_MPI_INTERFACE_HH
 /* -------------------------------------------------------------------------- */
 #include "mpi_interface.hh"
 #include <cstdlib>
 #include <numeric>
 #include <stdexcept>
 #include <tuple>
 #ifdef TAMAAS_USE_MPI
 #include <fftw3-mpi.h>
 #endif
 /* -------------------------------------------------------------------------- */
 namespace fftw_impl {
 namespace mpi_dummy {
 inline void init() {}
 inline void cleanup() {}
 inline auto local_size_many(int rank, const std::ptrdiff_t* size,
                             std::ptrdiff_t howmany) {
   return std::make_tuple(howmany * std::accumulate(size, size + rank,
                                                    std::ptrdiff_t{1},
                                                    std::multiplies<void>()),
                          size[0], 0);
 }
 }  // namespace mpi_dummy
 
 #ifdef TAMAAS_USE_MPI
 namespace mpi_impl {
 inline void init() { fftw_mpi_init(); }
 inline void cleanup() { fftw_mpi_cleanup(); }
 inline auto local_size_many(int rank, const std::ptrdiff_t* size,
                             std::ptrdiff_t howmany) {
   if (rank < 2)
     throw std::domain_error("FFTW-MPI cannot be used for 1D transforms");
 
   std::ptrdiff_t local_n0, local_n0_offset;
   auto res = fftw_mpi_local_size_many(
       rank, size, howmany, FFTW_MPI_DEFAULT_BLOCK, ::tamaas::mpi::comm::world(),
       &local_n0, &local_n0_offset);
   return std::make_tuple(res, local_n0, local_n0_offset);
 }
 }  // namespace mpi_impl
 namespace mpi = mpi_impl;
 #else
 namespace mpi = mpi_dummy;
 #endif
 }  // namespace fftw
 #endif
diff --git a/src/core/grid.cpp b/src/core/grid.cpp
index e4f6ad6..c8357d1 100644
--- a/src/core/grid.cpp
+++ b/src/core/grid.cpp
@@ -1,121 +1,122 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "tamaas.hh"
 #include <algorithm>
 #include <complex>
 #include <cstring>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 Grid<T, dim>::Grid() : GridBase<T>() {
   this->n.fill(0);
   this->strides.fill(1);
   this->nb_components = 1;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 Grid<T, dim>::Grid(const std::array<UInt, dim>& n, UInt nb_components,
                    value_type* data)
     : GridBase<T>() {
   this->n = n;
   this->nb_components = nb_components;
   UInt size = this->computeSize();
   this->data.wrapMemory(data, size);
   this->computeStrides();
 }
 
 template <typename T, UInt dim>
 Grid<T, dim>::Grid(const Grid<T, dim>& o)
     : GridBase<T>(o), n(o.n), strides(o.strides) {}
 
 template <typename T, UInt dim>
 Grid<T, dim>::Grid(Grid<T, dim>&& o) noexcept
     : GridBase<T>(std::move(o)), n(std::move(o.n)),
       strides(std::move(o.strides)) {}
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 void Grid<T, dim>::resize(const std::array<UInt, dim>& n) {
   this->resize(n.begin(), n.end());
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 void Grid<T, dim>::resize(const std::vector<UInt>& n) {
   TAMAAS_ASSERT(n.size() == dim, "Shape vector not matching grid dimensions");
   this->resize(n.begin(), n.end());
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 void Grid<T, dim>::resize(std::initializer_list<UInt> n) {
   TAMAAS_ASSERT(n.size() == dim,
                 "Shape initializer list not matching grid dimensions");
   this->resize(std::begin(n), std::end(n));
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 void Grid<T, dim>::computeStrides() {
   std::copy(n.begin() + 1, n.end(), strides.begin());
   strides[dim] = 1;
   strides[dim - 1] = this->nb_components;
   std::partial_sum(strides.rbegin(), strides.rend(), strides.rbegin(),
                    std::multiplies<UInt>());
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 void Grid<T, dim>::printself(std::ostream& str) const {
   str << "Grid(" << dim << ", " << this->nb_components << ") {";
   for (auto& val : *this) {
     str << val << ", ";
   }
   str << "\b\b}";
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// Class instanciation
 #define GRID_INSTANCIATE_TYPE(type)                                            \
   template class Grid<type, 1>;                                                \
   template class Grid<type, 2>;                                                \
   template class Grid<type, 3>
 
 GRID_INSTANCIATE_TYPE(Real);
 GRID_INSTANCIATE_TYPE(UInt);
 GRID_INSTANCIATE_TYPE(Complex);
 GRID_INSTANCIATE_TYPE(Int);
 GRID_INSTANCIATE_TYPE(bool);
 #undef GRID_INSTANCIATE_TYPE
 
 }  // namespace tamaas
diff --git a/src/core/grid.hh b/src/core/grid.hh
index ae683f9..a553792 100644
--- a/src/core/grid.hh
+++ b/src/core/grid.hh
@@ -1,219 +1,220 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef GRID_HH
 #define GRID_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_base.hh"
 #include "tamaas.hh"
 #include <array>
 #include <numeric>
 #include <utility>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Multi-dimensional & multi-component array class
  *
  * This class is a container for multi-component data stored on a multi-
  * dimensional grid.
  *
  * The access function is the parenthesis operator. For a grid of dimension d,
  * the operator takes d+1 arguments: the first d arguments are the position on
  * the grid and the last one is the component of the stored data.
  *
  * It is also possible to use the access operator with only one argument, it is
  * then considering the grid as a flat array, accessing the given cell of the
  * array.
  */
 template <typename T, UInt dim>
 class Grid : public GridBase<T> {
   template <typename... D>
   using is_valid_index = fold_trait<std::is_integral, D...>;
 
 public:
   /* ------------------------------------------------------------------------ */
   /* Types */
   /* ------------------------------------------------------------------------ */
   using value_type = T;
   using reference = value_type&;
   static constexpr UInt dimension = dim;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors */
   /* ------------------------------------------------------------------------ */
 public:
   /// Constructor by default (empty array)
   Grid();
   /// Constructor from iterators
   template <typename RandomAccessIterator>
   Grid(RandomAccessIterator begin, RandomAccessIterator end,
        UInt nb_components);
   /// Constructor
   Grid(const std::array<UInt, dim>& n, UInt nb_components)
       : Grid(std::begin(n), std::end(n), nb_components) {}
   /// Wrap on given data
   Grid(const std::array<UInt, dim>& n, UInt nb_components, value_type* data);
   /// Constructor with vectors
   Grid(const std::vector<UInt>& n, UInt nb_components)
       : Grid(std::begin(n), std::end(n), nb_components) {}
   /// Constructor with initializer list
   Grid(const std::initializer_list<UInt>& n, UInt nb_components)
       : Grid(std::begin(n), std::end(n), nb_components) {}
   /// Copy constructor
   Grid(const Grid& o);
   /// Move constructor (transfers data ownership)
   Grid(Grid&& o) noexcept;
   /// Destructor
   ~Grid() override = default;
 
 private:
   /// Init from standard container
   template <typename Container>
   void init(const Container& n, UInt nb_components);
 
 public:
   /* ------------------------------------------------------------------------ */
   /* Common operations */
   /* ------------------------------------------------------------------------ */
   /// Resize array
   void resize(const std::array<UInt, dim>& n);
   /// Resize array (from std::vector)
   void resize(const std::vector<UInt>& n);
   /// Resize array (from initializer list)
   void resize(std::initializer_list<UInt> n);
   /// Resize array (from iterators)
   template <typename ForwardIt>
   void resize(ForwardIt begin, ForwardIt end);
   /// Compute size
   inline UInt computeSize() const;
   /// Get grid dimension
   inline UInt getDimension() const override { return dim; }
   /// Compute strides
   void computeStrides();
   /// Print
   virtual void printself(std::ostream& str) const;
   /// Get sizes
   const std::array<UInt, dim>& sizes() const { return n; }
   /// Get strides
   const std::array<UInt, dim + 1>& getStrides() const { return this->strides; }
 
   /* ------------------------------------------------------------------------ */
   /* Access operators (these cannot be moved outside the class) */
   /* ------------------------------------------------------------------------ */
   /// Variadic access operator (non-const)
   template <typename... T1>
   inline std::enable_if_t<is_valid_index<T1...>::value, T&>
   operator()(T1... args) {
     /// Checking access integrity
     constexpr UInt nargs = sizeof...(T1);
     static_assert(nargs == dim + 1 || nargs == 1 || nargs == dim,
                   "number of arguments in operator() does not match dimension");
 
     constexpr UInt start = (nargs == 1) ? dim : 0;
     UInt offset = unpackOffset(0, start, args...);
     return this->data[offset];
   }
 
   /// Variadic access operator
   template <typename... T1>
   inline std::enable_if_t<is_valid_index<T1...>::value, const T&>
   operator()(T1... args) const {
     /// Checking access integrity
     constexpr UInt nargs = sizeof...(T1);
     static_assert(nargs == dim + 1 || nargs == 1 || nargs == dim,
                   "number of arguments in operator() does not match dimension");
 
     constexpr UInt start = (nargs == 1) ? dim : 0;
     UInt offset = unpackOffset(0, start, args...);
     return this->data[offset];
   }
 
   /// Tuple index access operator
   template <std::size_t tdim>
   inline T& operator()(std::array<UInt, tdim> tuple);
   template <std::size_t tdim>
   inline const T& operator()(std::array<UInt, tdim> tuple) const;
 
 private:
   /// Unpacking the arguments of variadic ()
   template <typename... T1>
   inline UInt unpackOffset(UInt offset, UInt index_pos, UInt index,
                            T1... rest) const;
   /// End case for recursion
   template <typename... T1>
   inline UInt unpackOffset(UInt offset, UInt index_pos, UInt index) const;
   /// Computing offset for a tuple index
   template <std::size_t tdim>
   inline UInt computeOffset(std::array<UInt, tdim> tuple) const;
 
   /* ------------------------------------------------------------------------ */
   /* Move/Copy operators */
   /* ------------------------------------------------------------------------ */
 public:
   using GridBase<T>::operator=;
   // = operator
   Grid& operator=(const Grid& other);
   // = operator (move)
   Grid& operator=(Grid&& other) noexcept;
 
   // Copy data from another grid
   template <typename T1>
   void copy(const Grid<T1, dim>& other);
   // Move data from another grid
   template <typename T1>
   void move(Grid<T1, dim>&& other) noexcept;
 
   // Wrap memory (non-const)
   void wrap(Grid& other) {
     GridBase<T>::wrap(other);
     std::copy(other.n.begin(), other.n.end(), n.begin());
     this->computeStrides();
   }
 
   // Wrap memory
   void wrap(const Grid& other) {
     GridBase<T>::wrap(other);
     std::copy(other.n.begin(), other.n.end(), n.begin());
     this->computeStrides();
   }
 
   /* ------------------------------------------------------------------------ */
   /* Member variables */
   /* ------------------------------------------------------------------------ */
 protected:
   std::array<UInt, dim> n;            ///< shape of grid: size per dimension
   std::array<UInt, dim + 1> strides;  ///< strides for access
 };
 
 }  // namespace tamaas
 
 /* -------------------------------------------------------------------------- */
 /* Inline/template function definitions                                       */
 /* -------------------------------------------------------------------------- */
 
 #include "grid_tmpl.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #endif  // GRID_HH
diff --git a/src/core/grid_base.hh b/src/core/grid_base.hh
index 4d5601d..0bb0fb2 100644
--- a/src/core/grid_base.hh
+++ b/src/core/grid_base.hh
@@ -1,341 +1,342 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef GRID_BASE_HH
 #define GRID_BASE_HH
 /* -------------------------------------------------------------------------- */
 #include "array.hh"
 #include "iterator.hh"
 #include "loop.hh"
 #include "mpi_interface.hh"
 #include "static_types.hh"
 #include "tamaas.hh"
 #include <cstddef>
 #include <limits>
 #include <utility>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Dimension agnostic grid with components stored per points
  */
 template <typename T>
 class GridBase {
 public:
   /// Constructor by default
   GridBase() = default;
   /// Copy constructor
   GridBase(const GridBase& o) { this->copy(o); }
   /// Move constructor (transfers data ownership)
   GridBase(GridBase&& o) noexcept
       : data(std::move(o.data)),
         nb_components(std::exchange(o.nb_components, 1)) {}
   /// Initialize with size
   explicit GridBase(UInt nb_points, UInt nb_components = 1) {
     setNbComponents(nb_components);
     this->resize(nb_points * nb_components);
   }
 
   /// Destructor
   virtual ~GridBase() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Iterator class */
   /* ------------------------------------------------------------------------ */
   using iterator = iterator_::iterator<T>;
   using const_iterator = iterator_::iterator<const T>;
   using value_type = T;
   using reference = value_type&;
 
   /// Get grid dimension
   virtual UInt getDimension() const { return 1; }
   /// Get internal data pointer (const)
   const T* getInternalData() const { return this->data.data(); }
   /// Get internal data pointer (non-const)
   T* getInternalData() { return this->data.data(); }
   /// Get number of components
   UInt getNbComponents() const { return nb_components; }
   /// Set number of components
   void setNbComponents(UInt n) { nb_components = n; }
   /// Get total size
   virtual UInt dataSize() const { return this->data.size(); }
   /// Get global data size
   UInt globalDataSize() const {
     return mpi::allreduce<operation::plus>(dataSize());
   }
   /// Get number of points
   UInt getNbPoints() const {
     return this->dataSize() / this->getNbComponents();
   }
   /// Get global number of points
   UInt getGlobalNbPoints() const {
     return this->globalDataSize() / this->getNbComponents();
   }
   /// Set components
   void uniformSetComponents(const GridBase<T>& vec);
   /// Resize
   void resize(UInt size) { this->data.assign(size, T(0.)); }
   /// Reserve storage w/o changing data logic
   void reserve(UInt size) { this->data.reserve(size); }
 
   /* ------------------------------------------------------------------------ */
   /* Iterator methods */
   /* ------------------------------------------------------------------------ */
   virtual iterator begin(UInt n = 1) {
     return iterator(this->getInternalData(), n);
   }
 
   virtual iterator end(UInt n = 1) {
     return iterator(this->getInternalData() + this->dataSize(), n);
   }
 
   virtual const_iterator begin(UInt n = 1) const {
     return const_iterator(this->getInternalData(), n);
   }
 
   virtual const_iterator end(UInt n = 1) const {
     return const_iterator(this->getInternalData() + this->dataSize(), n);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Operators */
   /* ------------------------------------------------------------------------ */
   inline T& operator()(UInt i) { return this->data[i]; }
 
   inline const T& operator()(UInt i) const { return this->data[i]; }
 
 #define VEC_OPERATOR(op)                                                       \
   template <typename T1>                                                       \
   GridBase& operator op(const GridBase<T1>& other)
 
   VEC_OPERATOR(+=);
   VEC_OPERATOR(*=);
   VEC_OPERATOR(-=);
   VEC_OPERATOR(/=);
 #undef VEC_OPERATOR
 
   template <typename T1>
   T dot(const GridBase<T1>& other) const;
 
 #define SCALAR_OPERATOR(op) GridBase& operator op(const T& e)
 
   SCALAR_OPERATOR(+=);
   SCALAR_OPERATOR(*=);
   SCALAR_OPERATOR(-=);
   SCALAR_OPERATOR(/=);
   SCALAR_OPERATOR(=);
 #undef SCALAR_OPERATOR
 
 /// Broadcast operators
 #define BROADCAST_OPERATOR(op)                                                 \
   template <typename DT, typename ST, UInt size>                               \
   GridBase& operator op(const StaticArray<DT, ST, size>& b)
 
   BROADCAST_OPERATOR(+=);
   BROADCAST_OPERATOR(-=);
   BROADCAST_OPERATOR(*=);
   BROADCAST_OPERATOR(/=);
   BROADCAST_OPERATOR(=);
 #undef BROADCAST_OPERATOR
 
   /* ------------------------------------------------------------------------ */
   /* Min/max */
   /* ------------------------------------------------------------------------ */
   T min() const;
   T max() const;
   T sum() const;
   T mean() const { return sum() / static_cast<T>(globalDataSize()); }
   T var() const;
   T l2norm() const { return std::sqrt(dot(*this)); }
 
   /* ------------------------------------------------------------------------ */
   /* Move/Copy */
   /* ------------------------------------------------------------------------ */
 
   GridBase& operator=(const GridBase& o) {
     this->copy(o);
     return *this;
   }
 
   GridBase& operator=(GridBase& o) {
     this->copy(o);
     return *this;
   }
 
   GridBase& operator=(GridBase&& o) noexcept {
     this->move(std::move(o));
     return *this;
   }
 
   template <typename T1>
   void copy(const GridBase<T1>& other) {
     if (other.dataSize() != this->dataSize())
       this->resize(other.dataSize());
     thrust::copy(other.begin(), other.end(), this->begin());
     nb_components = other.nb_components;
   }
 
   template <typename T1>
   void move(GridBase<T1>&& other) noexcept {
     data = std::move(other.data);
     nb_components = std::exchange(other.nb_components, 1);
   }
 
   GridBase& wrap(GridBase& o) {
     data.wrap(o.data);
     nb_components = o.nb_components;
     return *this;
   }
 
   GridBase& wrap(const GridBase& o) {
     data.wrap(o.data);
     nb_components = o.nb_components;
     return *this;
   }
 
 protected:
   Array<T> data;
   UInt nb_components = 1;
 };
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 void GridBase<T>::uniformSetComponents(const GridBase<T>& vec) {
   if (vec.dataSize() != this->nb_components)
     TAMAAS_EXCEPTION("Cannot set grid field with values of vector");
 
   auto begin_it{begin()};
   auto end_it{end()};  // silencing nvcc warnings
 
   for (auto it = begin(); it < end_it; ++it) {
     UInt i = it - begin_it;
     *it = vec(i % this->nb_components);
   }
 }
 
 /* --------------------------------------------------------------------------
  */
 
 #define SCALAR_OPERATOR_IMPL(op)                                               \
   template <typename T>                                                        \
   inline GridBase<T>& GridBase<T>::operator op(const T& e) {                   \
     Loop::loop([e] CUDA_LAMBDA(T& val) { val op e; }, *this);                  \
     return *this;                                                              \
   }
 
 SCALAR_OPERATOR_IMPL(+=)
 SCALAR_OPERATOR_IMPL(*=)
 SCALAR_OPERATOR_IMPL(-=)
 SCALAR_OPERATOR_IMPL(/=)
 SCALAR_OPERATOR_IMPL(=)
 
 #undef SCALAR_OPERATOR_IMPL
 
 /* -------------------------------------------------------------------------- */
 
 #define VEC_OPERATOR_IMPL(op)                                                  \
   template <typename T>                                                        \
   template <typename T1>                                                       \
   inline GridBase<T>& GridBase<T>::operator op(const GridBase<T1>& other) {    \
     TAMAAS_ASSERT(other.dataSize() == this->dataSize(),                        \
                   "surface size does not match");                              \
     Loop::loop([] CUDA_LAMBDA(T& x, const T1& y) { x op y; }, *this, other);   \
     return *this;                                                              \
   }
 
 VEC_OPERATOR_IMPL(+=)
 VEC_OPERATOR_IMPL(-=)
 VEC_OPERATOR_IMPL(*=)
 VEC_OPERATOR_IMPL(/=)
 #undef VEC_OPERATOR
 
 /* -------------------------------------------------------------------------- */
 
 #define BROADCAST_OPERATOR_IMPL(op)                                            \
   template <typename T>                                                        \
   template <typename DT, typename ST, UInt size>                               \
   GridBase<T>& GridBase<T>::operator op(const StaticArray<DT, ST, size>& b) {  \
     TAMAAS_ASSERT(this->dataSize() % size == 0,                                \
                   "Broadcast operator cannot broadcast"                        \
                       << size << " on array of size " << this->dataSize());    \
     Tensor<StaticArray, typename std::remove_const<DT>::type, size> a(b);      \
     Loop::loop([a] CUDA_LAMBDA(VectorProxy<T, size> g) { g op a; },            \
                range<VectorProxy<T, size>>(*this));                            \
     return *this;                                                              \
   }
 
 BROADCAST_OPERATOR_IMPL(+=)
 BROADCAST_OPERATOR_IMPL(-=)
 BROADCAST_OPERATOR_IMPL(*=)
 BROADCAST_OPERATOR_IMPL(/=)
 BROADCAST_OPERATOR_IMPL(=)
 #undef BROADCAST_OPERATOR_IMPL
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 inline T GridBase<T>::min() const {
   // const auto id = [] CUDA_LAMBDA (const T&x){return x;};
   return Loop::reduce<operation::min>([] CUDA_LAMBDA(const T& x) { return x; },
                                       *this);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 inline T GridBase<T>::max() const {
   return Loop::reduce<operation::max>([] CUDA_LAMBDA(const T& x) { return x; },
                                       *this);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 inline T GridBase<T>::sum() const {
   return Loop::reduce<operation::plus>([] CUDA_LAMBDA(const T& x) { return x; },
                                        *this);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 inline T GridBase<T>::var() const {
   const T mu = mean();
   const T var = Loop::reduce<operation::plus>(
       [mu] CUDA_LAMBDA(const T& x) { return (x - mu) * (x - mu); }, *this);
   return var / (globalDataSize() - 1);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 template <typename T1>
 T GridBase<T>::dot(const GridBase<T1>& other) const {
   return Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(const T& x, const T1& y) { return x * y; }, *this, other);
 }
 
 }  // namespace tamaas
 
 #endif  // GRID_BASE_HH
diff --git a/src/core/grid_hermitian.cpp b/src/core/grid_hermitian.cpp
index 463613a..6a351f6 100644
--- a/src/core/grid_hermitian.cpp
+++ b/src/core/grid_hermitian.cpp
@@ -1,37 +1,38 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "grid_hermitian.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 
 #define GRID_HERMITIAN_INSTANCIATE(type)                                       \
   template class GridHermitian<type, 1>;                                       \
   template class GridHermitian<type, 2>;                                       \
   template class GridHermitian<type, 3>
 
 GRID_HERMITIAN_INSTANCIATE(Real);
 #undef GRID_HERMITIAN_INSTANCIATE
 
 }  // namespace tamaas
diff --git a/src/core/grid_hermitian.hh b/src/core/grid_hermitian.hh
index cdde9b4..683fdb6 100644
--- a/src/core/grid_hermitian.hh
+++ b/src/core/grid_hermitian.hh
@@ -1,159 +1,160 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef GRID_HERMITIAN_HH
 #define GRID_HERMITIAN_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "tamaas.hh"
 #include <complex>
 #include <type_traits>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 static complex<Real> dummy;
 
 /**
  * @brief Multi-dimensional, multi-component herimitian array
  *
  * This class represents an array of hermitian data, meaning it has dimensions
  * of: n1 * n2 * n3 * ... * (nx / 2 + 1)
  *
  * However, it acts as a fully dimensioned array, returning a dummy reference
  * for data outside its real dimension, allowing one to write full (and
  * inefficient) loops without really worrying about the reduced dimension.
  *
  * It would however be better to just use the true dimensions of the surface
  * for all intents and purposes, as it saves computation time.
  */
 template <typename T, UInt dim>
 class GridHermitian : public Grid<complex<T>, dim> {
 public:
   using value_type = complex<T>;
   /* ------------------------------------------------------------------------ */
   /* Constructors */
   /* ------------------------------------------------------------------------ */
 public:
   GridHermitian() = default;
   GridHermitian(const GridHermitian& o) = default;
   GridHermitian(GridHermitian&& o) noexcept = default;
   using Grid<value_type, dim>::Grid;
   using Grid<complex<T>, dim>::operator=;
   /* ------------------------------------------------------------------------ */
   /* Access operators */
   /* ------------------------------------------------------------------------ */
   template <typename... T1>
   inline complex<T>& operator()(T1... args);
   template <typename... T1>
   inline const complex<T>& operator()(T1... args) const;
 
   static std::array<UInt, dim> hermitianDimensions(std::array<UInt, dim> n) {
     n[dim - 1] /= 2;
     n[dim - 1] += 1;
     return n;
   }
 
   template <typename Int,
             typename = std::enable_if_t<std::is_arithmetic<Int>::value>>
   static std::vector<Int> hermitianDimensions(std::vector<Int> n) {
     n.back() /= 2;
     n.back() += 1;
     return n;
   }
 
 private:
   template <typename... T1>
   inline void packTuple(UInt* t, UInt i, T1... args) const;
   template <typename... T1>
   inline void packTuple(UInt* t, UInt i) const;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline function definitions                                                */
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline void GridHermitian<T, dim>::packTuple(UInt* t, UInt i,
                                              T1... args) const {
   *t = i;
   packTuple(t + 1, args...);
 }
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline void GridHermitian<T, dim>::packTuple(UInt* t, UInt i) const {
   *t = i;
 }
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline complex<T>& GridHermitian<T, dim>::operator()(T1... args) {
   constexpr UInt nargs = sizeof...(T1);
   static_assert(nargs <= dim + 1, "Too many arguments");
   UInt last_index = std::get<nargs - 1>(std::forward_as_tuple(args...));
   if (nargs != 1 && last_index >= this->n[dim - 1]) {
     std::array<UInt, dim + 1> tuple = {{0}};
     packTuple(tuple.data(), args...);
 
     for (UInt i = 0; i < dim; i++) {
       if (tuple[i] && i != dim - 1)
         tuple[i] = this->n[i] - tuple[i];
       else if (tuple[i] && i == dim - 1)
         tuple[i] = 2 * (this->n[i] - 1) - tuple[i];
     }
 
     dummy = conj(this->Grid<complex<T>, dim>::operator()(tuple));
     return dummy;
   }
 
     return Grid<complex<T>, dim>::operator()(args...);
 }
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline const complex<T>& GridHermitian<T, dim>::operator()(T1... args) const {
   constexpr UInt nargs = sizeof...(T1);
   static_assert(nargs <= dim + 1, "Too many arguments");
   UInt last_index = std::get<nargs - 1>(std::forward_as_tuple(args...));
   if (nargs != 1 && last_index >= this->n[dim - 1]) {
     std::array<UInt, dim + 1> tuple = {{0}};
     packTuple(tuple.data(), args...);
 
     for (UInt i = 0; i < dim; i++) {
       if (tuple[i] && i != dim - 1)
         tuple[i] = this->n[i] - tuple[i];
       else if (tuple[i] && i == dim - 1)
         tuple[i] = 2 * (this->n[i] - 1) - tuple[i];
     }
 
     dummy = conj(this->Grid<complex<T>, dim>::operator()(tuple));
     return dummy;
   }
 
     return Grid<complex<T>, dim>::operator()(args...);
 }
 
 }  // namespace tamaas
 
 #endif  // GRID_HERMITIAN_HH
diff --git a/src/core/grid_tmpl.hh b/src/core/grid_tmpl.hh
index b564bb9..12293b7 100644
--- a/src/core/grid_tmpl.hh
+++ b/src/core/grid_tmpl.hh
@@ -1,152 +1,153 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef GRID_TMPL_HH
 #define GRID_TMPL_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "tamaas.hh"
 
 namespace tamaas {
 
 template <typename T, UInt dim>
 template <typename RandomAccessIterator>
 Grid<T, dim>::Grid(RandomAccessIterator begin, RandomAccessIterator end,
                    UInt nb_components)
     : GridBase<T>() {
   if (end - begin != dim) {
     TAMAAS_EXCEPTION("Provided sizes (" << end - begin
                                         << ") for grid do not match dimension ("
                                         << dim << ")");
   }
 
   this->nb_components = nb_components;
   this->resize(begin, end);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 inline UInt Grid<T, dim>::computeSize() const {
   UInt size = 1;
   for (UInt i = 0; i < dim; i++)
     size *= n[i];
   size *= this->nb_components;
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 template <typename ForwardIt>
 void Grid<T, dim>::resize(ForwardIt begin, ForwardIt end) {
   std::copy(begin, end, this->n.begin());
   UInt size = this->computeSize();
   GridBase<T>::resize(size);
   this->computeStrides();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline UInt Grid<T, dim>::unpackOffset(UInt offset, UInt index_pos, UInt index,
                                        T1... rest) const {
   offset += index * strides[index_pos];
   return unpackOffset(offset, index_pos + 1, rest...);  // tail-rec bb
 }
 
 template <typename T, UInt dim>
 template <typename... T1>
 inline UInt Grid<T, dim>::unpackOffset(UInt offset, UInt index_pos,
                                        UInt index) const {
   return offset + index * strides[index_pos];
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 template <std::size_t tdim>
 inline UInt Grid<T, dim>::computeOffset(std::array<UInt, tdim> tuple) const {
   static_assert(tdim == dim or tdim == dim + 1, "Tuple dimension is invalid");
   return std::inner_product(tuple.begin(), tuple.end(), strides.begin(), 0);
 }
 
 template <typename T, UInt dim>
 template <std::size_t tdim>
 inline T& Grid<T, dim>::operator()(std::array<UInt, tdim> tuple) {
   UInt offset = computeOffset(tuple);
   return this->data[offset];
 }
 
 template <typename T, UInt dim>
 template <std::size_t tdim>
 inline const T& Grid<T, dim>::operator()(std::array<UInt, tdim> tuple) const {
   UInt offset = computeOffset(tuple);
   return this->data[offset];
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 Grid<T, dim>& Grid<T, dim>::operator=(const Grid<T, dim>& other) {
   this->copy(other);
   return *this;
 }
 
 template <typename T, UInt dim>
 Grid<T, dim>& Grid<T, dim>::operator=(Grid<T, dim>&& other) noexcept {
   this->move(std::move(other));
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 template <typename T1>
 void Grid<T, dim>::copy(const Grid<T1, dim>& other) {
   GridBase<T>::copy(other);
   this->n = other.n;
   this->strides = other.strides;
 }
 
 template <typename T, UInt dim>
 template <typename T1>
 void Grid<T, dim>::move(Grid<T1, dim>&& other) noexcept {
   GridBase<T>::move(std::move(other));
   this->n = std::move(other.n);
   this->strides = std::move(other.strides);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Stream operator                                                            */
 /* -------------------------------------------------------------------------- */
 
 template <typename T, UInt dim>
 inline std::ostream& operator<<(std::ostream& stream,
                                 const Grid<T, dim>& _this) {
   _this.printself(stream);
   return stream;
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // GRID_TMPL_HH
diff --git a/src/core/grid_view.hh b/src/core/grid_view.hh
index 484f943..02ef903 100644
--- a/src/core/grid_view.hh
+++ b/src/core/grid_view.hh
@@ -1,163 +1,164 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef GRID_VIEW_HH
 #define GRID_VIEW_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "tamaas.hh"
 #include <vector>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /**
  * @brief View type on grid
  * This is a view on a *contiguous* chunk of data defined by a grid
  */
 template <template <typename, UInt> class Base, typename T, UInt base_dim,
           UInt dim>
 class GridView : public Base<T, dim> {
 public:
   using iterator = typename Base<T, dim>::iterator;
   using const_iterator = typename Base<T, dim>::const_iterator;
   using value_type = typename Base<T, dim>::value_type;
   using referecence = typename Base<T, dim>::reference;
 
 public:
   /// Constructor
   GridView(GridBase<typename Base<T, dim>::value_type>& grid_base,
            const std::vector<UInt>& multi_index, Int component = -1);
   /// Move constructor
   GridView(GridView&& o) noexcept
       : Base<T, dim>(std::forward<Base<T, dim>>(o)),
         grid(std::exchange(o.grid, nullptr)) {}
 
   /// Destructor
   ~GridView() override = default;
 
   UInt dataSize() const override { return this->computeSize(); }
 
   // Forbid these methods for obvious reasons
   void reserve(UInt size) = delete;
   void resize(UInt size) = delete;
 
   /// Iterators
   iterator begin(UInt /*n*/ = 1) override {
     return iterator(this->getInternalData(), this->strides.back());
   }
 
   iterator end(UInt /*n*/ = 1) override {
     return iterator(this->getInternalData() +
                         this->dataSize() * this->strides.back(),
                     this->strides.back());
   }
 
   const_iterator begin(UInt /*n*/ = 1) const override {
     return const_iterator(this->getInternalData(), this->strides.back());
   }
 
   const_iterator end(UInt /*n*/ = 1) const override {
     return const_iterator(this->getInternalData() +
                               this->dataSize() * this->strides.back(),
                           this->strides.back());
   }
 
 protected:
   Base<T, base_dim>* grid;
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <typename, UInt> class Base, typename T, UInt base_dim,
           typename... Args>
 GridView<Base, T, base_dim, base_dim - sizeof...(Args)>
 make_view(Base<T, base_dim>& base, Args... indices) {
   std::vector<UInt> multi_index = {static_cast<UInt>(indices)...};
   return GridView<Base, T, base_dim, base_dim - sizeof...(Args)>(base,
                                                                  multi_index);
 }
 
 template <template <typename, UInt> class Base, typename T, UInt base_dim>
 GridView<Base, T, base_dim, base_dim>
 make_component_view(Base<T, base_dim>& base, UInt component) {
   std::vector<UInt> multi_index{};
   return GridView<Base, T, base_dim, base_dim>(base, multi_index, component);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Template implementation */
 /* -------------------------------------------------------------------------- */
 
 template <template <typename, UInt> class Base, typename T, UInt base_dim,
           UInt dim>
 GridView<Base, T, base_dim, dim>::GridView(
     GridBase<typename Base<T, dim>::value_type>& grid_base,
     const std::vector<UInt>& multi_index, Int component)
     : Base<T, dim>(), grid(nullptr) {
   // static_assert(base_dim >= dim,
   // 		"view dimension must be >= than the base class");
 
   // Checking view type
   grid = dynamic_cast<Base<T, base_dim>*>(&grid_base);
 
   if (!grid)
     TAMAAS_EXCEPTION("given base type is incompatible with view");
 
   constexpr Int dim_offset = Int{base_dim} - Int{dim};
 
   if (dim_offset >= 0 and dim_offset != static_cast<Int>(multi_index.size()))
     TAMAAS_EXCEPTION("Number of blocked indices ("
                      << multi_index.size()
                      << ") does not match view dimension (" << base_dim
                      << " -> " << dim << ")");
 
   std::copy(grid->sizes().begin() + std::max(dim_offset, Int{0}),
             grid->sizes().end(), this->n.begin() + std::max(-dim_offset, Int{0}));
   std::copy(grid->getStrides().begin() + std::max(dim_offset, Int{0}),
             grid->getStrides().end(),
             this->strides.begin() + std::max(-dim_offset, Int{0}));
 
   if (dim_offset < 0)
     std::fill_n(this->n.begin(), -dim_offset, 1);
 
   if (component == -1) {  // view all components
     this->nb_components = grid->getNbComponents();
     component = 0;
   } else if (component >= 0 and
              component < static_cast<Int>(
                              grid->getNbComponents())) {  // view one component
     this->nb_components = 1;
     this->strides.back() = grid->getNbComponents();
   } else
     TAMAAS_EXCEPTION("Components out of bounds for view");
 
   auto offset = std::inner_product(multi_index.begin(), multi_index.end(),
                                    grid->getStrides().begin(), component);
 
   this->data.wrapMemory(grid->getInternalData() + offset,
                         grid->dataSize() - offset);
 }
 
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
 
 #endif  // GRID_VIEW_HH
diff --git a/src/core/iterator.hh b/src/core/iterator.hh
index 7ab65ee..43f1baf 100644
--- a/src/core/iterator.hh
+++ b/src/core/iterator.hh
@@ -1,187 +1,188 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ITERATOR_HH
 #define ITERATOR_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <cstddef>
 #include <iterator>
 #include <thrust/iterator/iterator_categories.h>
 #include <utility>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace iterator_ {
 
 template <typename T>
 class iterator {
 
 public:
   using value_type = T;
   using difference_type = std::ptrdiff_t;
   using pointer = T*;
   using reference = T&;
   using iterator_category = thrust::random_access_device_iterator_tag;
 
   template <typename U>
   friend class iterator;
 
 public:
   /// constructor
   __device__ __host__ iterator(pointer data, difference_type step_size)
       : data(data), step(step_size) {}
   /// copy constructor
   __device__ __host__ iterator(const iterator& o)
       : data(o.data), step(o.step) {}
   /// move constructor
   __device__ __host__ iterator(iterator&& o) noexcept
       : data(exchange(o.data, nullptr)), step(exchange(o.step, 0)) {}
 
   /// copy from a different qualified type
   template <typename U,
             typename = std::enable_if_t<std::is_convertible<T, U>::value>>
   __device__ __host__ iterator(const iterator<U>& o)
       : data(o.data), step(o.step) {}
   /// move from a different qualified type
   template <typename U,
             typename = std::enable_if_t<std::is_convertible<T, U>::value>>
   __device__ __host__ iterator(iterator<U>&& o)
       : data(exchange(o.data, nullptr)), step(exchange(o.step, 0)) {}
 
   // assign
   __device__ __host__ iterator& operator=(const iterator& o) {
     data = o.data;
     step = o.step;
     return *this;
   }
 
   // move
   __device__ __host__ iterator& operator=(iterator&& o) noexcept {
     data = exchange(o.data, nullptr);
     step = exchange(o.step, 0);
     return *this;
   }
 
 public:
   /// dereference iterator
   __device__ __host__ inline reference operator*() { return *data; }
 
   /// dereference iterator
   __device__ __host__ inline reference operator*() const { return *data; }
 
   /// increment with given offset
   __device__ __host__ inline iterator& operator+=(difference_type a) {
     data += a * step;
     return *this;
   }
 
   /// increment iterator
   __device__ __host__ inline iterator& operator++() {
     *this += 1;
     return *this;
   }
 
   /// comparison
   __device__ __host__ inline bool operator<(const iterator& a) const {
     return data < a.data;
   }
 
   /// inequality
   __device__ __host__ inline bool operator!=(const iterator& a) const {
     return data != a.data;
   }
 
   /// equality
   __device__ __host__ inline bool operator==(const iterator& a) const {
     return data == a.data;
   }
 
   /// needed for OpenMP range calculations
   __device__ __host__ inline difference_type
   operator-(const iterator& a) const {
     return (data - a.data) / step;
   }
 
   void setStep(difference_type s) { step = s; }
 
 protected:
   T* data;
   difference_type step;
 };
 
 template <typename T>
 class iterator_view : iterator<T> {
 public:
   using value_type = T;
   using difference_type = std::ptrdiff_t;
   using pointer = T*;
   using reference = T&;
 
   /// Constructor
   iterator_view(pointer data, std::size_t start, ptrdiff_t offset,
                 std::vector<UInt> strides, std::vector<UInt> sizes)
       : iterator<T>(data, start, offset), strides(std::move(strides)),
         n(std::move(sizes)), tuple(strides.size()) {}
 
   iterator_view(const iterator_view& o)
       : iterator<T>(o), strides(o.strides), n(o.n), tuple(o.tuple) {}
 
   iterator_view& operator=(const iterator_view& o) {
     iterator<T>::operator=(o);
     strides = o.strides;
     n = o.n;
     tuple = o.tuple;
   }
 
 protected:
   void computeAccessOffset() {
     UInt index_copy = this->index;
 
     this->tuple.back() = index_copy % this->n.back();
     index_copy -= this->tuple.back();
     index_copy /= this->n.back();
 
     /// Computing tuple from index
     for (UInt d = this->tuple.size() - 2; d > 0; d--) {
       this->tuple[d] = index_copy % this->n[d];
       index_copy -= this->tuple[d];
       index_copy /= this->n[d];
     }
 
     this->tuple[0] = index_copy;
 
     this->access_offset = 0;
     for (UInt i = 0; i < this->tuple.size(); ++i)
       this->access_offset += this->tuple[i] * this->strides[i];
   }
 
   std::vector<UInt> strides;
   std::vector<UInt> n;
   std::vector<UInt> tuple;
 };
 
 }  // end namespace iterator_
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // ITERATOR_HH
diff --git a/src/core/logger.cpp b/src/core/logger.cpp
index 781cbd7..34fb17e 100644
--- a/src/core/logger.cpp
+++ b/src/core/logger.cpp
@@ -1,65 +1,66 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "logger.hh"
 #include "mpi_interface.hh"
 #include <cstdlib>
 #include <iostream>
 #include <map>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 LogLevel Logger::current_level = LogLevel::info;
 
 std::ostream& operator<<(std::ostream& o, const LogLevel& val) {
   static const std::map<LogLevel, std::string> strings{
       {LogLevel::debug, "DEBUG"},
       {LogLevel::info, "INFO"},
       {LogLevel::warning, "WARNING"},
       {LogLevel::error, "ERROR"}};
 
   o << strings.at(val);
   return o;
 }
 
 Logger::~Logger() noexcept {
   if (wish_level >= current_level and
       not(mpi::rank() != 0 and wish_level == LogLevel::info)) {
     std::cerr << stream.str();
     std::cerr.flush();
   }
 }
 
 std::ostream& Logger::get(LogLevel level) {
   wish_level = level;
 
   // Print rank if not info level
   if (wish_level != LogLevel::info)
     stream << '[' << mpi::rank() << '|' << mpi::size() << "] "
            << wish_level << ": ";
 
   return stream;
 }
 
 void Logger::setLevel(LogLevel level) { current_level = level; }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/core/logger.hh b/src/core/logger.hh
index 9c8b223..bcbc490 100644
--- a/src/core/logger.hh
+++ b/src/core/logger.hh
@@ -1,65 +1,66 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef LOGGER_HH
 #define LOGGER_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <sstream>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /// Log levels enumeration
 enum class LogLevel { debug = 0, info = 1, warning = 2, error = 3 };
 
 /**
  @brief Logging class
  Inspired from https://www.drdobbs.com/cpp/logging-in-c/201804215
  by Petru Marginean.
 */
 class Logger {
 public:
   /// Writing to stderr
   ~Logger() noexcept;
 
   /// Get stream
   std::ostream& get(LogLevel level = LogLevel::debug);
 
   /// Get wish log level
   decltype(auto) getWishLevel() const { return wish_level; }
 
   /// Get current log level
   static decltype(auto) getCurrentLevel() { return current_level; }
 
   /// Set acceptable logging level
   static void setLevel(LogLevel level);
 
 private:
   static LogLevel current_level;
 
   std::ostringstream stream;
   LogLevel wish_level = LogLevel::debug;
 };
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 
 #endif  // LOGGER_HH
diff --git a/src/core/loop.cpp b/src/core/loop.cpp
index e0da8b7..b2fc333 100644
--- a/src/core/loop.cpp
+++ b/src/core/loop.cpp
@@ -1,30 +1,31 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "loop.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
diff --git a/src/core/loop.hh b/src/core/loop.hh
index 702794f..08f3d23 100644
--- a/src/core/loop.hh
+++ b/src/core/loop.hh
@@ -1,235 +1,236 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef LOOP_HH
 #define LOOP_HH
 /* -------------------------------------------------------------------------- */
 #include "loops/apply.hh"
 #include "loops/loop_utils.hh"
 #include "mpi_interface.hh"
 #include "ranges.hh"
 #include "tamaas.hh"
 #include <thrust/execution_policy.h>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
 #include <thrust/transform_reduce.h>
 #include <thrust/tuple.h>
 #include <thrust/version.h>
 #include <type_traits>
 #include <utility>
 
 namespace tamaas {
 
 template <typename T>
 struct is_policy : std::false_type {};
 
 template <>
 struct is_policy<thrust::detail::host_t> : std::true_type {};
 template <>
 struct is_policy<const thrust::detail::host_t> : std::true_type {};
 template <>
 struct is_policy<const thrust::detail::host_t&> : std::true_type {};
 
 // device_t == host_t when thrust backend is CPP
 #if TAMAAS_LOOP_BACKEND != TAMAAS_LOOP_BACKEND_CPP
 template <>
 struct is_policy<thrust::detail::device_t> : std::true_type {};
 template <>
 struct is_policy<const thrust::detail::device_t> : std::true_type {};
 template <>
 struct is_policy<const thrust::detail::device_t&> : std::true_type {};
 #endif
 
 /**
  * @brief Singleton class for automated loops using lambdas
 
  * This class is sweet candy :) It provides abstraction of the paralelism
  * paradigm used in loops and allows simple and less error-prone loop syntax,
  * with minimum boiler plate. I love it <3
  */
 class Loop {
 public:
   /// Helper class to count iterations within lambda-loop
   template <typename T>
   class arange {
   public:
     using it_type = thrust::counting_iterator<T>;
     using reference = typename it_type::reference;
     arange(T start, T size) : start(start), range_size(size) {}
     it_type begin(UInt /*i*/ = 1) const { return it_type(T(start)); }
     it_type end(UInt /*i*/ = 1) const { return it_type(range_size); }
     UInt getNbComponents() const { return 1; }
 
   private:
     T start, range_size;
   };
 
   template <typename T>
   static arange<T> range(T size) {
     return arange<T>(0, size);
   }
 
   template <typename T, typename U>
   static arange<T> range(U start, T size) {
     return arange<T>(start, size);
   }
 
 public:
   /// Replacement for thrust::transform_iterator which copies values
   template <typename Iterator, typename Functor, typename Value>
   class transform_iterator
       : public thrust::iterator_adaptor<
             transform_iterator<Iterator, Functor, Value>, Iterator, Value,
             thrust::use_default, thrust::use_default, Value> {
     Functor func;
 
   public:
     using super_t =
         thrust::iterator_adaptor<transform_iterator<Iterator, Functor, Value>,
                                  Iterator, Value, thrust::use_default,
                                  thrust::use_default, Value>;
     __host__ __device__ transform_iterator(const Iterator& x,
                                            const Functor& func)
         : super_t(x), func(func) {}
 
     friend class thrust::iterator_core_access;
 
   private:
     __host__ __device__ auto dereference() const
         -> decltype(func(*this->base())) {
       return func(*this->base());
     }
   };
 
 public:
   /// Loop functor over ranges
   template <typename Functor, typename... Ranges>
   static auto loop(Functor&& func, Ranges&&... ranges) ->
       typename std::enable_if<not is_policy<Functor>::value, void>::type {
     loopImpl(thrust::device, std::forward<Functor>(func),
              std::forward<Ranges>(ranges)...);
   }
 
   /// Loop over ranges with non-default policy
   template <typename DerivedPolicy, typename Functor, typename... Ranges>
   static void loop(const thrust::execution_policy<DerivedPolicy>& policy,
                    Functor&& func, Ranges&&... ranges) {
     loopImpl(policy, std::forward<Functor>(func),
              std::forward<Ranges>(ranges)...);
   }
 
 private:
   template <typename T>
   using reference_type = typename std::decay<T>::type::reference;
 
 public:
   /// Reduce functor over ranges
   template <operation op = operation::plus, typename Functor,
             typename... Ranges>
   static auto reduce(Functor&& func, Ranges&&... ranges) ->
       typename std::enable_if<
           not is_policy<Functor>::value,
           decltype(func(std::declval<reference_type<Ranges>>()...))>::type {
     return reduceImpl<op>(thrust::device, std::forward<Functor>(func),
                           std::forward<Ranges>(ranges)...);
   }
 
   /// Reduce over ranges with non-default policy
   template <operation op = operation::plus, typename DerivedPolicy,
             typename Functor, typename... Ranges>
   static auto reduce(const thrust::execution_policy<DerivedPolicy>& policy,
                      Functor&& func, Ranges&&... ranges)
       -> decltype(func(std::declval<reference_type<Ranges>>()...)) {
     return reduceImpl<op>(policy, std::forward<Functor>(func),
                           std::forward<Ranges>(ranges)...);
   }
 
 private:
   /// Loop over ranges and apply functor
   template <typename DerivedPolicy, typename Functor, typename... Ranges>
   static void loopImpl(const thrust::execution_policy<DerivedPolicy>& policy,
                        Functor&& func, Ranges&&... ranges);
   /// Loop over ranges, apply functor and reduce result
   template <operation op, typename DerivedPolicy, typename Functor,
             typename... Ranges>
   static auto reduceImpl(const thrust::execution_policy<DerivedPolicy>& policy,
                          Functor&& func, Ranges&&... ranges)
       -> decltype(func(std::declval<reference_type<Ranges>>()...));
 
 public:
   /// Constructor
   Loop() = delete;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Template implementation                                                    */
 /* -------------------------------------------------------------------------- */
 template <typename DerivedPolicy, typename Functor, typename... Ranges>
 void Loop::loopImpl(const thrust::execution_policy<DerivedPolicy>& policy,
                     Functor&& func, Ranges&&... ranges) {
   auto begin = thrust::make_zip_iterator(thrust::make_tuple(ranges.begin()...));
   auto end = thrust::make_zip_iterator(thrust::make_tuple(ranges.end()...));
 
   checkLoopSize(ranges...);
 
   thrust::for_each(policy, begin, end,
                    detail::ApplyFunctor<Functor>(std::forward<Functor>(func)));
 
 #if (defined(TAMAAS_USE_CUDA) && THRUST_VERSION < 100904)
   cudaDeviceSynchronize();
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 template <operation op, typename DerivedPolicy, typename Functor,
           typename... Ranges>
 auto Loop::reduceImpl(const thrust::execution_policy<DerivedPolicy>& policy,
                       Functor&& func, Ranges&&... ranges)
     -> decltype(func(std::declval<reference_type<Ranges>>()...)) {
   using return_type = decltype(func(std::declval<reference_type<Ranges>>()...));
   using apply_type = detail::ApplyFunctor<Functor, return_type>;
 
   checkLoopSize(ranges...);
 
   auto applier = apply_type(func);
   detail::reduction_helper<op, return_type> red_helper;
 
   auto begin_zip =
       thrust::make_zip_iterator(thrust::make_tuple(ranges.begin()...));
   auto end_zip = thrust::make_zip_iterator(thrust::make_tuple(ranges.end()...));
 
   transform_iterator<decltype(begin_zip), apply_type, return_type> begin(
       begin_zip, applier);
   transform_iterator<decltype(end_zip), apply_type, return_type> end(end_zip,
                                                                      applier);
 
   auto result =
       thrust::reduce(policy, begin, end, red_helper.init(), red_helper);
 #if (defined(TAMAAS_USE_CUDA) && THRUST_VERSION < 100904)
   cudaDeviceSynchronize();
 #endif
   return mpi::allreduce<op>(std::move(result));
 }
 
 }  // namespace tamaas
 
 #endif  // LOOP_HH
diff --git a/src/core/loops/apply.hh b/src/core/loops/apply.hh
index 15a3a87..caf138c 100644
--- a/src/core/loops/apply.hh
+++ b/src/core/loops/apply.hh
@@ -1,84 +1,85 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef APPLY_HH
 #define APPLY_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <cstddef>
 #include <thrust/tuple.h>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace detail {
 
 /// Helper function for application of a functor on a thrust::tuple
 template <size_t nargs>
 struct Apply {
   template <typename Functor, typename Tuple, typename... Args>
   __host__ __device__ static auto apply(Functor&& func, Tuple&& t,
                                         Args&&... args)
       -> decltype(Apply<nargs - 1>::apply(std::forward<Functor>(func),
                                           std::forward<Tuple>(t),
                                           thrust::get<nargs - 1>(t),
                                           std::forward<Args>(args)...)) {
     return Apply<nargs - 1>::apply(
         std::forward<Functor>(func), std::forward<Tuple>(t),
         thrust::get<nargs - 1>(t), std::forward<Args>(args)...);
   }
 };
 
 template <>
 struct Apply<0> {
   template <typename Functor, typename Tuple, typename... Args>
   __host__ __device__ static auto apply(Functor&& func, Tuple&& /*t*/,
                                         Args&&... args)
       -> decltype(func(std::forward<Args>(args)...)) {
     return func(std::forward<Args>(args)...);
   }
 };
 
 /// Helper class for functor application in thrust
 template <typename Functor, typename ret_type = void>
 class ApplyFunctor {
 
 public:
   __host__ __device__ ApplyFunctor(const Functor& functor) : functor(functor) {}
   __host__ __device__ ApplyFunctor(const ApplyFunctor& o)
       : functor(o.functor) {}
 
   template <typename Tuple>
   __host__ __device__ ret_type operator()(Tuple&& t) const {
     return Apply<thrust::tuple_size<typename std::remove_reference<
         Tuple>::type>::value>::apply(functor, std::forward<Tuple>(t));
   }
 
 private:
   const Functor& functor;
 };
 
 }  // namespace detail
 
 }  // namespace tamaas
 
 #endif
diff --git a/src/core/loops/loop_utils.hh b/src/core/loops/loop_utils.hh
index a8027bf..217b8b3 100644
--- a/src/core/loops/loop_utils.hh
+++ b/src/core/loops/loop_utils.hh
@@ -1,96 +1,97 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef LOOP_UTILS_HH
 #define LOOP_UTILS_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <limits>
 #include <thrust/functional.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace detail {
 
 template <bool only_points = false, typename... Grids>
 UInt loopSize(Grids&&... grids) {
   return (only_points)
              ? std::get<0>(std::forward_as_tuple(grids...)).getNbPoints()
              : std::get<0>(std::forward_as_tuple(grids...)).dataSize();
 }
 
 template <typename... Sizes>
 void areAllEqual(bool /*unused*/ /*unused*/,
                  std::ptrdiff_t /*unused*/ /*unused*/) {}
 
 template <typename... Sizes>
 void areAllEqual(bool result, std::ptrdiff_t prev, std::ptrdiff_t current) {
   if (!(result && prev == current))
     TAMAAS_EXCEPTION("Cannot loop over ranges that do not have the same size!");
 }
 
 template <typename... Sizes>
 void areAllEqual(bool result, std::ptrdiff_t prev, std::ptrdiff_t current,
                  Sizes... rest) {
   areAllEqual(result && prev == current, current, rest...);
 }
 }  // namespace detail
 
 template <typename... Ranges>
 void checkLoopSize(Ranges&&... ranges) {
   detail::areAllEqual(true, (ranges.end() - ranges.begin())...);
 }
 
 namespace detail {
 template <operation op, typename ReturnType>
 struct reduction_helper;
 
 template <typename ReturnType>
 struct reduction_helper<operation::plus, ReturnType>
     : public thrust::plus<ReturnType> {
   ReturnType init() const { return ReturnType(0); }
 };
 
 template <typename ReturnType>
 struct reduction_helper<operation::times, ReturnType>
     : public thrust::multiplies<ReturnType> {
   ReturnType init() const { return ReturnType(1); }
 };
 
 template <typename ReturnType>
 struct reduction_helper<operation::min, ReturnType>
     : public thrust::minimum<ReturnType> {
   ReturnType init() const { return std::numeric_limits<ReturnType>::max(); }
 };
 
 template <typename ReturnType>
 struct reduction_helper<operation::max, ReturnType>
     : public thrust::maximum<ReturnType> {
   ReturnType init() const { return std::numeric_limits<ReturnType>::lowest(); }
 };
 
 }  // namespace detail
 
 }  // namespace tamaas
 
 #endif  // __LOOP_UTILS_HH
diff --git a/src/core/mpi_interface.cpp b/src/core/mpi_interface.cpp
index 1915521..d3d2f0a 100644
--- a/src/core/mpi_interface.cpp
+++ b/src/core/mpi_interface.cpp
@@ -1,39 +1,40 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mpi_interface.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace mpi_dummy {
 comm comm::world;
 }
 
 #ifdef TAMAAS_USE_MPI
 namespace mpi_impl {
 comm& comm::world() {
   static comm _world{MPI_COMM_WORLD};
   return _world;
 }
 }  // namespace mpi_impl
 #endif
 
 }  // namespace tamaas
diff --git a/src/core/mpi_interface.hh b/src/core/mpi_interface.hh
index 6b51092..5821196 100644
--- a/src/core/mpi_interface.hh
+++ b/src/core/mpi_interface.hh
@@ -1,279 +1,280 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MPI_INTERFACE_HH
 #define MPI_INTERFACE_HH
 /* -------------------------------------------------------------------------- */
 #include "static_types.hh"
 #include "tamaas.hh"
 #include <type_traits>
 #include <vector>
 #ifdef TAMAAS_USE_MPI
 #include <mpi.h>
 #endif
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 /// Contains mock mpi functions
 namespace mpi_dummy {
 
 struct comm {
   static comm world;
 };
 
 struct sequential {
   static void enter(){};
   static void exit(){};
 };
 
 struct sequential_guard {
   sequential_guard() { sequential::enter(); }
   ~sequential_guard() { sequential::exit(); }
 };
 
 enum class thread : int { single, funneled, serialized, multiple };
 
 inline bool initialized() { return false; }
 inline bool finalized() { return false; }
 
 inline int init(int* /*unused*/, char*** /*unused*/) { return 0; }
 inline int init_thread(int* /*unused*/, char*** /*unused*/, thread /*unused*/,
                        thread* provided) {
   *provided = thread::funneled;
   return 0;
 }
 
 inline int finalize() { return 0; }
 
 inline int rank(comm /*unused*/ = comm::world) { return 0; }
 inline int size(comm /*unused*/ = comm::world) { return 1; }
 
 template <operation op = operation::plus, typename T>
 inline decltype(auto) reduce(T&& val, comm /*unused*/ = comm::world) {
   return std::forward<T>(val);
 }
 
 template <operation op = operation::plus, typename T>
 inline decltype(auto) allreduce(T&& val, comm /*unused*/ = comm::world) {
   return std::forward<T>(val);
 }
 
 template <typename T>
 inline decltype(auto) gather(const T* send, T* recv, int count,
                              comm /*unused*/ = comm::world) {
   if (send == recv)
     return;
   thrust::copy_n(send, count, recv);
 }
 
 template <typename T>
 inline decltype(auto) scatter(const T* send, T* recv, int count,
                               comm /*unused*/ = comm::world) {
   if (send == recv)
     return;
   thrust::copy_n(send, count, recv);
 }
 
 template <typename T>
 inline decltype(auto) scatterv(const T* send,
                                const std::vector<int>& /*unused*/,
                                const std::vector<int>& /*unused*/, T* recv,
                                int recvcount, comm /*unused*/ = comm::world) {
   scatter(send, recv, recvcount);
 }
 
 template <typename T>
 inline decltype(auto) bcast(T* /*unused*/, int /*unused*/,
                             comm /*unused*/ = comm::world) {}
 
 }  // namespace mpi_dummy
 
 /* -------------------------------------------------------------------------- */
 #ifdef TAMAAS_USE_MPI
 /// Contains real mpi functions
 namespace mpi_impl {
 
 /// MPI_Comm wrapper
 struct comm {
   MPI_Comm _comm;
 
   operator MPI_Comm() const { return _comm; }
 
   static comm& world();
 };
 
 struct sequential {
   static void enter() { comm::world()._comm = MPI_COMM_SELF; }
   static void exit() { comm::world()._comm = MPI_COMM_WORLD; }
 };
 
 struct sequential_guard {
   sequential_guard() { sequential::enter(); }
   ~sequential_guard() { sequential::exit(); }
 };
 
 /// MPI Thread level
 enum class thread : int {
   single = MPI_THREAD_SINGLE,
   funneled = MPI_THREAD_FUNNELED,
   serialized = MPI_THREAD_SERIALIZED,
   multiple = MPI_THREAD_MULTIPLE
 };
 
 template <typename T>
 struct type_trait;
 
 #define TYPE(t, mpi_t)                                                         \
   template <>                                                                  \
   struct type_trait<t> {                                                       \
     static constexpr MPI_Datatype value = mpi_t;                               \
   }
 TYPE(double, MPI_DOUBLE);
 TYPE(int, MPI_INT);
 TYPE(unsigned int, MPI_UNSIGNED);
 TYPE(long double, MPI_LONG_DOUBLE);
 TYPE(long, MPI_LONG);
 TYPE(unsigned long, MPI_UNSIGNED_LONG);
 TYPE(::thrust::complex<double>, MPI_CXX_DOUBLE_COMPLEX);
 TYPE(::thrust::complex<long double>, MPI_CXX_LONG_DOUBLE_COMPLEX);
 TYPE(bool, MPI_CXX_BOOL);
 #undef TYPE
 
 template <operation op>
 struct operation_trait;
 
 #define OPERATION(op, mpi_op)                                                  \
   template <>                                                                  \
   struct operation_trait<operation::op> {                                      \
     static constexpr MPI_Op value = mpi_op;                                    \
   }
 OPERATION(plus, MPI_SUM);
 OPERATION(min, MPI_MIN);
 OPERATION(max, MPI_MAX);
 OPERATION(times, MPI_PROD);
 #undef OPERATION
 
 inline bool initialized() {
   int has_init;
   MPI_Initialized(&has_init);
   return has_init != 0;
 }
 
 inline bool finalized() {
   int has_final;
   MPI_Finalized(&has_final);
   return has_final != 0;
 }
 
 inline int init(int* argc, char*** argv) { return MPI_Init(argc, argv); }
 
 inline int init_thread(int* argc, char*** argv, thread required,
                        thread* provided) {
   return MPI_Init_thread(argc, argv, static_cast<int>(required),
                          reinterpret_cast<int*>(provided));
 }
 
 inline int finalize() { return MPI_Finalize(); }
 
 inline int rank(comm communicator = comm::world()) {
   int rank;
   MPI_Comm_rank(communicator, &rank);
   return rank;
 }
 
 inline int size(comm communicator = comm::world()) {
   int size;
   MPI_Comm_size(communicator, &size);
   return size;
 }
 
 template <operation op = operation::plus, typename T>
 inline decltype(auto) reduce(T val, comm communicator = comm::world()) {
   MPI_Reduce(&val, &val, 1, type_trait<T>::value, operation_trait<op>::value, 0,
              communicator);
   return val;
 }
 
 template <operation op = operation::plus, typename T,
           typename = std::enable_if_t<std::is_arithmetic<T>::value or
                                       std::is_same<T, Complex>::value>>
 inline decltype(auto) allreduce(T val, comm communicator = comm::world()) {
   MPI_Allreduce(&val, &val, 1, type_trait<T>::value, operation_trait<op>::value,
                 communicator);
   return val;
 }
 
 template <operation op = operation::plus, typename DT, typename ST, UInt n>
 inline decltype(auto) allreduce(const StaticVector<DT, ST, n>& v,
                                 comm communicator = comm::world()) {
   Vector<DT, n> res;
   MPI_Allreduce(v.begin(), res.begin(), n, type_trait<DT>::value,
                 operation_trait<op>::value, communicator);
   return res;
 }
 
 template <operation op = operation::plus, typename DT, typename ST, UInt n,
           UInt m>
 inline decltype(auto) allreduce(const StaticMatrix<DT, ST, n, m>& v,
                                 comm communicator = comm::world()) {
   Matrix<DT, n, m> res;
   MPI_Allreduce(v.begin(), res.begin(), n * m, type_trait<DT>::value,
                 operation_trait<op>::value, communicator);
   return res;
 }
 
 template <typename T>
 inline decltype(auto) gather(const T* send, T* recv, int count,
                              comm communicator = comm::world()) {
   MPI_Gather(send, count, type_trait<T>::value, recv, count,
              type_trait<T>::value, 0, communicator);
 }
 
 template <typename T>
 inline decltype(auto) scatter(const T* send, T* recv, int count,
                               comm communicator = comm::world()) {
   MPI_Scatter(send, count, type_trait<T>::value, recv, count,
               type_trait<T>::value, 0, communicator);
 }
 
 template <typename T>
 inline decltype(auto)
 scatterv(const T* send, const std::vector<int>& sendcounts,
          const std::vector<int>& displs, T* recv, int recvcount,
          comm communicator = comm::world()) {
   MPI_Scatterv(send, sendcounts.data(), displs.data(), type_trait<T>::value,
                recv, recvcount, type_trait<T>::value, 0, communicator);
 }
 
 template <typename T>
 inline decltype(auto) bcast(T* buffer, int count,
                             comm communicator = comm::world()) {
   MPI_Bcast(buffer, count, type_trait<T>::value, 0, communicator);
 }
 
 }  // namespace mpi_impl
 namespace mpi = mpi_impl;
 #else
 namespace mpi = mpi_dummy;
 #endif  // TAMAAS_USE_MPI
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // MPI_INTERFACE_HH
diff --git a/src/core/partitioner.hh b/src/core/partitioner.hh
index 883fa3a..975c4cd 100644
--- a/src/core/partitioner.hh
+++ b/src/core/partitioner.hh
@@ -1,144 +1,145 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef PARTITIONER_HH
 #define PARTITIONER_HH
 /* -------------------------------------------------------------------------- */
 #include "fftw/interface.hh"
 #include "grid.hh"
 #include "mpi_interface.hh"
 #include "tamaas.hh"
 #include <algorithm>
 #include <array>
 #include <cstdlib>
 #include <functional>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 template <UInt dim>
 struct Partitioner {
   template <typename Container>
   static decltype(auto) global_size(Container local) {
     local.front() = mpi::allreduce<operation::plus>(local.front());
     return local;
   }
 
   template <typename T>
   static decltype(auto) global_size(const Grid<T, dim>& grid) {
     return global_size(grid.sizes());
   }
 
   template <typename Container>
   static decltype(auto) local_size(Container global) {
     if (dim == 1)
       return global;
 
     auto tup = fftw::mpi::local_size_many(dim, cast_size(global).data(), 1);
     global.front() = static_cast<UInt>(std::get<1>(tup));
     return global;
   }
 
   template <typename T>
   static decltype(auto) local_size(const Grid<T, dim>& grid) {
     return local_size(grid.sizes());
   }
 
   static decltype(auto) local_size(std::initializer_list<UInt> list) {
     std::array<UInt, dim> global;
     std::copy_n(list.begin(), dim, global.begin());
     return local_size(global);
   }
 
   template <typename Container>
   static decltype(auto) local_offset(const Container& global) {
     if (dim == 1)
       return std::size_t{0};
     auto tup = fftw::mpi::local_size_many(dim, cast_size(global).data(), 1);
     return static_cast<std::size_t>(std::get<2>(tup));
   }
 
   template <typename T>
   static decltype(auto) local_offset(const Grid<T, dim>& grid) {
     auto offset = local_offset(global_size(grid.sizes()));
     return offset * grid.getStrides().front();
   }
 
   static decltype(auto) local_offset(std::initializer_list<UInt> list) {
     std::array<UInt, dim> global;
     std::copy_n(list.begin(), dim, global.begin());
     return local_offset(global);
   }
 
   template <typename Container>
   static decltype(auto) cast_size(const Container& s) {
     std::array<std::ptrdiff_t, dim> n;
     std::copy_n(s.cbegin(), dim, n.begin());
     return n;
   }
 
   static decltype(auto) alloc_size(const std::array<UInt, dim>& global,
                                    UInt howmany) {
     if (dim == 1)
       return std::accumulate(global.begin(), global.end(), std::size_t{1},
                              std::multiplies<void>());
     auto tup =
         fftw::mpi::local_size_many(dim, cast_size(global).data(), howmany);
     return static_cast<std::size_t>(std::get<0>(tup));
   }
 
   template <typename T>
   static Grid<T, dim> gather(const Grid<T, dim>& send) {
     Grid<T, dim> result(global_size(send), send.getNbComponents());
     mpi::gather(send.getInternalData(), result.getInternalData(),
                 send.dataSize());
     return result;
   }
 
   template <typename T>
   static Grid<T, dim> scatter(const Grid<T, dim>& send) {
     auto global = send.sizes();
     auto components = send.getNbComponents();
     auto n = send.getStrides().front();
 
     mpi::bcast(global.data(), global.size());
     mpi::bcast(&components, 1);
     mpi::bcast(&n, 1);
 
     auto tup =
         fftw::mpi::local_size_many(dim, cast_size(global).data(), components);
 
     std::vector<int> disp(mpi::size()), sendcounts(mpi::size());
 
     sendcounts[0] = std::get<1>(tup) * n;
     disp[0] = std::get<2>(tup) * n;
 
     mpi::gather(sendcounts.data(), sendcounts.data(), 1);
     mpi::gather(disp.data(), disp.data(), 1);
 
     Grid<T, dim> result(local_size(global), components);
     mpi::scatterv(send.getInternalData(), sendcounts, disp,
                   result.getInternalData(), result.dataSize());
     return result;
   }
 };
 
 }  // namespace tamaas
 #endif
diff --git a/src/core/ranges.hh b/src/core/ranges.hh
index 3de87e7..013c400 100644
--- a/src/core/ranges.hh
+++ b/src/core/ranges.hh
@@ -1,118 +1,119 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef RANGES_HH
 #define RANGES_HH
 /* -------------------------------------------------------------------------- */
 #include "iterator.hh"
 #include "static_types.hh"
 #include "mpi_interface.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /// Range class for complex iterators
 template <typename LocalType, typename ValueType, UInt local_size>
 class Range {
 
 public:
   class iterator : public iterator_::iterator<ValueType> {
     using parent = iterator_::iterator<ValueType>;
 
   public:
     using value_type = LocalType;
     using reference = value_type;
     iterator(const parent& o) : parent(o) {}
 
     inline reference operator*() { return LocalType(this->data); }
     inline reference operator*() const { return LocalType(this->data); }
   };
 
 public:
   // useful type trait
   template <typename Container>
   struct is_valid_container
       : std::is_same<
             std::remove_cv_t<typename std::decay_t<Container>::value_type>,
             std::remove_cv_t<ValueType>> {};
 
 public:
   using value_type = LocalType;
   using reference = value_type&&;
 
   /// Construct from a container
   template <class Container>
   Range(Container&& cont) : _begin(cont.begin()), _end(cont.end()) {
     if (cont.getNbComponents() != local_size)
       TAMAAS_EXCEPTION(
           "Number of components does not match local tensor type size ("
           << cont.getNbComponents() << ", expected " << local_size << ")");
     _begin.setStep(local_size);
     _end.setStep(local_size);
   }
 
   /// Construct from two iterators
   Range(iterator _begin, iterator _end)
       : _begin(std::move(_begin)), _end(std::move(_end)) {}
 
   iterator begin() { return _begin; }
   iterator end() { return _end; }
 
   Range headless() const {
     iterator shift(_begin);
     if (mpi::rank() == 0)
       ++shift;
     return Range{shift, _end};
   }
 
 private:
   iterator _begin, _end;
 };
 
 /// Make range with proxy type
 template <typename LocalType, class Container>
 std::enable_if_t<
     is_proxy<LocalType>::value,
     Range<LocalType, typename LocalType::value_type, LocalType::size>>
 range(Container&& cont) {
   using RangeClass =
       Range<LocalType, typename LocalType::value_type, LocalType::size>;
   static_assert(
       RangeClass::template is_valid_container<Container>::value,
       "Mismatch between range's value type and container's value type");
   return RangeClass(std::forward<Container>(cont));
 }
 
 /// Make range with standard type
 template <typename LocalType, class Container>
 std::enable_if_t<not is_proxy<LocalType>::value, Range<LocalType, LocalType, 1>>
 range(Container&& cont) {
   using RangeClass = Range<LocalType, LocalType, 1>;
   static_assert(
       RangeClass::template is_valid_container<Container>::value,
       "Mismatch between range's value type and container's value type");
   return RangeClass(std::forward<Container>(cont));
 }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 
 #endif
diff --git a/src/core/static_types.hh b/src/core/static_types.hh
index c04c8d3..269dd0e 100644
--- a/src/core/static_types.hh
+++ b/src/core/static_types.hh
@@ -1,801 +1,802 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef STATIC_TYPES_HH
 #define STATIC_TYPES_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <thrust/detail/config/host_device.h>
 #include <thrust/sort.h>
 #include <type_traits>
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 
 namespace detail {
 /// \cond HIDDEN_SYMBOLS
 template <UInt acc, UInt n, UInt... ns>
 struct product_tail_rec : product_tail_rec<acc * n, ns...> {};
 /// \endcond
 
 template <UInt acc, UInt n>
 struct product_tail_rec<acc, n> : std::integral_constant<UInt, acc * n> {};
 
 /// \cond HIDDEN_SYMBOLS
 template <UInt N, UInt n, UInt... ns>
 struct get_rec : get_rec<N - 1, ns...> {};
 /// \endcond
 
 template <UInt n, UInt... ns>
 struct get_rec<0, n, ns...> : std::integral_constant<UInt, n> {};
 }  // namespace detail
 
 template <UInt... ns>
 struct product : detail::product_tail_rec<1, ns...> {};
 
 template <UInt N, UInt... ns>
 struct get : detail::get_rec<N, ns...> {};
 
 template <typename T>
 struct is_arithmetic : std::is_arithmetic<T> {};
 
 template <typename T>
 struct is_arithmetic<thrust::complex<T>> : std::true_type {};
 
 template <UInt dim>
 struct voigt_size;
 
 template <>
 struct voigt_size<3> : std::integral_constant<UInt, 6> {};
 
 template <>
 struct voigt_size<2> : std::integral_constant<UInt, 3> {};
 
 template <>
 struct voigt_size<1> : std::integral_constant<UInt, 1> {};
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * @brief Static Array
  *
  * This class is meant to be a small and fast object for intermediate
  * calculations, possibly on wrapped memory belonging to a grid. Support type
  * show be either a pointer or a C array. It should not contain any virtual
  * method.
  */
 template <typename DataType, typename SupportType, UInt _size>
 class StaticArray {
   static_assert(std::is_array<SupportType>::value or
                     std::is_pointer<SupportType>::value,
                 "the support type of StaticArray should be either a pointer or "
                 "a C-array");
 
   using T = DataType;
   using T_bare = typename std::remove_cv_t<T>;
 
 public:
   using value_type = T;
   static constexpr UInt size = _size;
 
 public:
   StaticArray() = default;
   ~StaticArray() = default;
   StaticArray(const StaticArray&) = delete;
   StaticArray(StaticArray&&) = delete;
   StaticArray& operator=(StaticArray&&) = delete;
 
 public:
   /// Access operator
   __device__ __host__ auto operator()(UInt i) -> T& {
     // TAMAAS_ASSERT(i < n, "Access out of bounds");
     return _mem[i];
   }
 
   /// Access operator
   __device__ __host__ auto operator()(UInt i) const -> const T& {
     // TAMAAS_ASSERT(i < n, "Access out of bounds");
     return _mem[i];
   }
 
   /// Scalar product
   template <typename DT, typename ST>
   __device__ __host__ auto dot(const StaticArray<DT, ST, size>& o) const
       -> T_bare {
     decltype(T_bare(0) * DT(0)) res = 0;
     for (UInt i = 0; i < size; ++i)
       res += (*this)(i)*o(i);
     return res;
   }
 
   /// L2 norm squared
   __device__ __host__ T_bare l2squared() const { return this->dot(*this); }
 
   /// L2 norm
   __device__ __host__ T_bare l2norm() const { return std::sqrt(l2squared()); }
 
   /// Sum of all elements
   __device__ __host__ T_bare sum() const {
     T_bare res = 0;
     for (UInt i = 0; i < size; ++i)
       res += (*this)(i);
     return res;
   }
 
 #define VECTOR_OP(op)                                                          \
   template <typename DT, typename ST>                                          \
   __device__ __host__ void operator op(const StaticArray<DT, ST, size>& o) {   \
     for (UInt i = 0; i < size; ++i)                                            \
       (*this)(i) op o(i);                                                      \
   }
 
   VECTOR_OP(+=)
   VECTOR_OP(-=)
   VECTOR_OP(*=)
   VECTOR_OP(/=)
 #undef VECTOR_OP
 
 #define SCALAR_OP(op)                                                          \
   template <typename T1>                                                       \
   __device__ __host__ std::enable_if_t<is_arithmetic<T1>::value, StaticArray&> \
   operator op(const T1& x) {                                                   \
     for (UInt i = 0; i < size; ++i)                                            \
       (*this)(i) op x;                                                         \
     return *this;                                                              \
   }
 
   SCALAR_OP(+=)
   SCALAR_OP(-=)
   SCALAR_OP(*=)
   SCALAR_OP(/=)
   SCALAR_OP(=)
 #undef SCALAR_OP
 
   /// Overriding the implicit copy operator
   __device__ __host__ StaticArray& operator=(const StaticArray& o) {
     copy(o);
     return *this;
   }
 
   template <typename DT, typename ST>
   __device__ __host__ void operator=(const StaticArray<DT, ST, size>& o) {
     copy(o);
   }
 
   template <typename DT, typename ST>
   __device__ __host__ StaticArray& copy(const StaticArray<DT, ST, size>& o) {
     for (UInt i = 0; i < size; ++i)
       (*this)(i) = o(i);
     return *this;
   }
 
   T* begin() { return _mem; }
   const T* begin() const { return _mem; }
 
   T* end() { return _mem + size; }
   const T* end() const { return _mem + size; }
 
 private:
   template <typename U>
   using valid_size_t = std::enable_if_t<(size > 0), U>;
 
 public:
   __host__ __device__ valid_size_t<T&> front() { return *_mem; }
 
   __host__ __device__ valid_size_t<const T&> front() const { return *_mem; }
 
   __host__ __device__ valid_size_t<T&> back() { return _mem[size - 1]; }
 
   __host__ __device__ valid_size_t<const T&> back() const {
     return _mem[size - 1];
   }
 
 protected:
   SupportType _mem;
 };
 
 /**
  * @brief Static Tensor
  *
  * This class implements a multi-dimensional tensor behavior.
  */
 template <typename DataType, typename SupportType = DataType*, UInt... dims>
 class StaticTensor
     : public StaticArray<DataType, SupportType, product<dims...>::value> {
   using parent = StaticArray<DataType, SupportType, product<dims...>::value>;
   using T = DataType;
 
 public:
   static constexpr UInt dim = sizeof...(dims);
   using parent::operator=;
 
 private:
   template <typename... Idx>
   __device__ __host__ static UInt unpackOffset(UInt offset, UInt index,
                                                Idx... rest) {
     constexpr UInt size = sizeof...(rest);
     offset += index;
     offset *= get<dim - size, dims...>::value;
     return unpackOffset(offset, rest...);
   }
 
   template <typename... Idx>
   __device__ __host__ static UInt unpackOffset(UInt offset, UInt index) {
     return offset + index;
   }
 
 public:
   template <typename... Idx>
   __device__ __host__ const T& operator()(Idx... idx) const {
     return parent::operator()(unpackOffset(0, idx...));
   }
 
   template <typename... Idx>
   __device__ __host__ T& operator()(Idx... idx) {
     return parent::operator()(unpackOffset(0, idx...));
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Common Static Types */
 /* -------------------------------------------------------------------------- */
 // Forward declaration
 template <typename DataType, typename SupportType, UInt n>
 class StaticVector;
 template <typename DataType, typename SupportType, UInt n>
 class StaticSymMatrix;
 
 /* -------------------------------------------------------------------------- */
 
 template <typename DataType, typename SupportType, UInt n, UInt m>
 class StaticMatrix : public StaticTensor<DataType, SupportType, n, m> {
   using T = DataType;
   using T_bare = typename std::remove_cv_t<T>;
 
 public:
   using StaticTensor<DataType, SupportType, n, m>::operator=;
 
   // /// Initialize from a symmetric matrix
   template <typename DT, typename ST>
   __device__ __host__ std::enable_if_t<n == m>
   fromSymmetric(const StaticSymMatrix<DT, ST, n>& o);
   /// Outer product of two vectors
   template <typename DT1, typename ST1, typename DT2, typename ST2>
   __device__ __host__ void outer(const StaticVector<DT1, ST1, n>& a,
                                  const StaticVector<DT2, ST2, m>& b);
 
   template <typename DT1, typename ST1, typename DT2, typename ST2, UInt l>
   __device__ __host__ void mul(const StaticMatrix<DT1, ST1, n, l>& a,
                                const StaticMatrix<DT2, ST2, l, m>& b) {
     (*this) = T(0);
     for (UInt i = 0; i < n; ++i)
       for (UInt j = 0; j < m; ++j)
         for (UInt k = 0; k < l; ++k)
           (*this)(i, j) += a(i, k) * b(k, j);
   }
 
   __device__ __host__ std::enable_if_t<n == m, T_bare> trace() const {
     T_bare res{0};
     for (UInt i = 0; i < n; ++i)
       res += (*this)(i, i);
     return res;
   }
 
   template <typename DT1, typename ST1>
   __device__ __host__ std::enable_if_t<n == m>
   deviatoric(const StaticMatrix<DT1, ST1, n, m>& mat, Real factor = n) {
     auto norm_trace = mat.trace() / factor;
     for (UInt i = 0; i < n; ++i)
       for (UInt j = 0; j < m; ++j)
         (*this)(i, j) = mat(i, j) - (i == j) * norm_trace;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Vector class with size determined at compile-time
 template <typename DataType, typename SupportType, UInt n>
 class StaticVector : public StaticTensor<DataType, SupportType, n> {
   using T = std::remove_cv_t<DataType>;
 
 public:
   using StaticTensor<DataType, SupportType, n>::operator=;
   /// Matrix-vector product
   template <bool transpose, typename DT1, typename ST1, typename DT2,
             typename ST2, UInt m>
   __device__ __host__ void mul(const StaticMatrix<DT1, ST1, n, m>& mat,
                                const StaticVector<DT2, ST2, m>& vec) {
     *this = T(0);
     for (UInt i = 0; i < n; ++i)
       for (UInt j = 0; j < m; ++j)
         (*this)(i) +=
             ((transpose) ? mat(j, i) : mat(i, j)) * vec(j);  // can be optimized
   }
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Symmetric matrix in Voigt notation
 template <typename DataType, typename SupportType, UInt n>
 class StaticSymMatrix
     : public StaticVector<DataType, SupportType, voigt_size<n>::value> {
   using parent = StaticVector<DataType, SupportType, voigt_size<n>::value>;
   using T = std::remove_cv_t<DataType>;
 
 private:
   template <typename DT, typename ST, typename BinOp>
   __device__ __host__ void sym_binary(const StaticMatrix<DT, ST, n, n>& m,
                                       BinOp&& op) {
     for (UInt i = 0; i < n; ++i)
       op((*this)(i), m(i, i));
 
     const auto a = 0.5 * std::sqrt(2);
     for (UInt j = n - 1, b = n; j > 0; --j)
       for (Int i = j - 1; i >= 0; --i)
         op((*this)(b++), a * (m(i, j) + m(j, i)));
   }
 
 public:
   /// Copy values from matrix and symmetrize
   template <typename DT, typename ST>
   __device__ __host__ void symmetrize(const StaticMatrix<DT, ST, n, n>& m) {
     sym_binary(m, [](auto&& v, auto&& w) { v = w; });
   }
 
   /// Add values from symmetrized matrix
   template <typename DT, typename ST>
   __device__ __host__ void operator+=(const StaticMatrix<DT, ST, n, n>& m) {
     sym_binary(m, [](auto&& v, auto&& w) { v += w; });
   }
 
   __device__ __host__ auto trace() const {
     std::remove_cv_t<DataType> res = 0;
     for (UInt i = 0; i < n; ++i)
       res += (*this)(i);
     return res;
   }
 
   template <typename DT, typename ST>
   __device__ __host__ void deviatoric(const StaticSymMatrix<DT, ST, n>& m,
                                       Real factor = n) {
     auto tr = m.trace() / factor;
     for (UInt i = 0; i < n; ++i)
       (*this)(i) = m(i) - tr;
     for (UInt i = n; i < voigt_size<n>::value; ++i)
       (*this)(i) = m(i);
   }
 
   using parent::operator+=;
   using parent::operator=;
 };
 
 /* -------------------------------------------------------------------------- */
 
 // Implementation of constructor from symmetric matrix
 template <typename DataType, typename SupportType, UInt n, UInt m>
 template <typename DT, typename ST>
 __device__ __host__ std::enable_if_t<n == m>
 StaticMatrix<DataType, SupportType, n, m>::fromSymmetric(
     const StaticSymMatrix<DT, ST, n>& o) {
   for (UInt i = 0; i < n; ++i)
     (*this)(i, i) = o(i);
 
   // We use Mendel notation for the vector representation
   const auto a = 1. / std::sqrt(2);
   for (UInt j = n - 1, b = n; j > 0; --j)
     for (Int i = j - 1; i >= 0; --i)
       (*this)(i, j) = (*this)(j, i) = a * o(b++);
 }
 
 // Implementation of outer product
 template <typename DataType, typename SupportType, UInt n, UInt m>
 template <typename DT1, typename ST1, typename DT2, typename ST2>
 __device__ __host__ void StaticMatrix<DataType, SupportType, n, m>::outer(
     const StaticVector<DT1, ST1, n>& a, const StaticVector<DT2, ST2, m>& b) {
   for (UInt i = 0; i < n; ++i)
     for (UInt j = 0; j < m; ++j)
       (*this)(i, j) = a(i) * b(j);
 }
 
 /* -------------------------------------------------------------------------- */
 /* On the stack static types */
 /* -------------------------------------------------------------------------- */
 template <template <typename, typename, UInt...> class StaticParent,
           UInt... dims>
 struct static_size_helper : product<dims...> {};
 
 template <UInt n>
 struct static_size_helper<StaticSymMatrix, n> : voigt_size<n> {};
 
 template <template <typename, typename, UInt...> class StaticParent, typename T,
           UInt... dims>
 class Tensor
     : public StaticParent<
           T, T[static_size_helper<StaticParent, dims...>::value], dims...> {
   static constexpr UInt size = static_size_helper<StaticParent, dims...>::value;
   using parent = StaticParent<T, T[size], dims...>;
 
 public:
   using parent::operator=;
   using parent::copy;
 
   /// Default constructor
   Tensor() = default;
   /// Construct with default value
   __device__ __host__ Tensor(T val) { *this = val; }
   /// Construct from array
   __device__ __host__ Tensor(const std::array<T, size>& arr) {
     // we use size to ensure static loop unrolling
     for (UInt i = 0; i < size; ++i)
       this->_mem[i] = arr[i];
   }
 
   /// Copy from array
   __device__ __host__ Tensor& operator=(const std::array<T, size>& arr) {
     // we use size to ensure static loop unrolling
     for (UInt i = 0; i < size; ++i)
       (*this)(i) = arr[i];
   }
 
   /// Construct by copy from static tensor
   template <typename DT, typename ST>
   __device__ __host__ Tensor(const StaticParent<DT, ST, dims...>& o) {
     copy(o);
   }
 
   __device__ __host__ Tensor(const Tensor& o) : parent() { copy(o); }
   __device__ __host__ Tensor& operator=(const Tensor& o) {
     copy(o);
     return *this;
   }
 
   __device__ __host__ Tensor(Tensor&& o) noexcept { copy(o); }
 };
 
 template <typename T, UInt n, UInt m>
 using Matrix = Tensor<StaticMatrix, T, n, m>;
 
 template <typename T, UInt n>
 using SymMatrix = Tensor<StaticSymMatrix, T, n>;
 
 template <typename T, UInt n>
 using Vector = Tensor<StaticVector, T, n>;
 
 /* -------------------------------------------------------------------------- */
 /* Proxy Static Types */
 /* -------------------------------------------------------------------------- */
 
 /// Proxy type for tensor
 template <template <typename, typename, UInt...> class StaticParent, typename T,
           UInt... dims>
 class TensorProxy : public StaticParent<T, T*, dims...> {
   using parent = StaticParent<T, T*, dims...>;
 
 public:
   /// Explicit construction from data location
   __device__ __host__ explicit TensorProxy(T* spot) { this->_mem = spot; }
   /// Explicit construction from lvalue-reference
   __device__ __host__ explicit TensorProxy(T& spot) : TensorProxy(&spot) {}
   /// Construction from static tensor
   template <typename DataType, typename SupportType>
   __device__ __host__
   TensorProxy(StaticParent<DataType, SupportType, dims...>& o)
       : TensorProxy(o.begin()) {}
 
   using parent::operator=;
 
   __device__ __host__ TensorProxy(const TensorProxy& o) { this->_mem = o._mem; }
   __device__ __host__ TensorProxy& operator=(const TensorProxy& o) {
     this->copy(o);
     return *this;
   }
   __device__ __host__ TensorProxy(TensorProxy&& o) noexcept
       : TensorProxy(exchange(o._mem, nullptr)) {}
 
 public:
   using stack_type = Tensor<StaticParent, T, dims...>;
 };
 
 template <typename T, UInt n, UInt m>
 using MatrixProxy = TensorProxy<StaticMatrix, T, n, m>;
 
 template <typename T, UInt n>
 using SymMatrixProxy = TensorProxy<StaticSymMatrix, T, n>;
 
 template <typename T, UInt n>
 using VectorProxy = TensorProxy<StaticVector, T, n>;
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 /* Arithmetic operators creating temporaries */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /* Simple operators */
 /* -------------------------------------------------------------------------- */
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt dim>
 __device__ __host__ Vector<decltype(DT1(0) + DT2(0)), dim>
 operator+(const StaticVector<DT1, ST1, dim>& a,
           const StaticVector<DT2, ST2, dim>& b) {
   Vector<decltype(DT1(0) + DT2(0)), dim> res(a);
   res += b;
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt dim>
 __device__ __host__ Vector<decltype(DT1(0) - DT2(0)), dim>
 operator-(const StaticVector<DT1, ST1, dim>& a,
           const StaticVector<DT2, ST2, dim>& b) {
   Vector<decltype(DT1(0) - DT2(0)), dim> res(a);
   res -= b;
   return res;
 }
 
 template <typename DT1, typename ST1, UInt dim>
 __device__ __host__ Vector<decltype(DT1(0)), dim>
 operator-(const StaticVector<DT1, ST1, dim>& a) {
   Vector<decltype(DT1(0)), dim> res(a);
   res *= -1;
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n,
           UInt m>
 __device__ __host__ Matrix<decltype(DT1(0) + DT2(0)), n, m>
 operator+(const StaticMatrix<DT1, ST1, n, m>& a,
           const StaticMatrix<DT2, ST2, n, m>& b) {
   Matrix<decltype(DT1(0) + DT2(0)), n, m> res(a);
   res += b;
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n,
           UInt m>
 __device__ __host__ Matrix<decltype(DT1(0) - DT2(0)), n, m>
 operator-(const StaticMatrix<DT1, ST1, n, m>& a,
           const StaticMatrix<DT2, ST2, n, m>& b) {
   Matrix<decltype(DT1(0) - DT2(0)), n, m> res(a);
   res -= b;
   return res;
 }
 
 template <typename DT1, typename ST1, UInt n, UInt m>
 __device__ __host__ Matrix<decltype(DT1(0)), n, m>
 operator-(const StaticMatrix<DT1, ST1, n, m>& a) {
   Matrix<decltype(DT1(0)), n, m> res(a);
   res *= -1;
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n>
 __device__ __host__ SymMatrix<decltype(DT1(0) + DT2(0)), n>
 operator+(const StaticSymMatrix<DT1, ST1, n>& a,
           const StaticSymMatrix<DT2, ST2, n>& b) {
   SymMatrix<decltype(DT1(0) + DT2(0)), n> res(a);
   res += b;
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n>
 __device__ __host__ SymMatrix<decltype(DT1(0) - DT2(0)), n>
 operator-(const StaticSymMatrix<DT1, ST1, n>& a,
           const StaticSymMatrix<DT2, ST2, n>& b) {
   SymMatrix<decltype(DT1(0) - DT2(0)), n> res(a);
   res -= b;
   return res;
 }
 
 template <typename DT1, typename ST1, UInt dim>
 __device__ __host__ SymMatrix<decltype(DT1(0)), dim>
 operator-(const StaticSymMatrix<DT1, ST1, dim>& a) {
   SymMatrix<decltype(DT1(0)), dim> res(a);
   res *= -1;
   return res;
 }
 
 template <typename DT, typename ST, typename T, UInt n,
           typename = std::enable_if_t<is_arithmetic<T>::value>>
 __device__ __host__ Vector<decltype(DT(0) * T(0)), n>
 operator*(const StaticVector<DT, ST, n>& a, const T& b) {
   Vector<decltype(DT(0) * T(0)), n> res{a};
   res *= b;
   return res;
 }
 
 // symmetry
 template <typename DT, typename ST, typename T, UInt n,
           typename = std::enable_if_t<is_arithmetic<T>::value>>
 __device__ __host__ Vector<decltype(DT(0) * T(0)), n>
 operator*(const T& b, const StaticVector<DT, ST, n>& a) {
   return a * b;
 }
 
 template <typename DT, typename ST, typename T, UInt n, UInt m,
           typename = std::enable_if_t<is_arithmetic<T>::value>>
 __device__ __host__ Matrix<decltype(DT(0) * T(0)), n, m>
 operator*(const StaticMatrix<DT, ST, n, m>& a, const T& b) {
   Matrix<decltype(DT(0) * T(0)), n, m> res{a};
   res *= b;
   return res;
 }
 
 // symmetry
 template <typename DT, typename ST, typename T, UInt n, UInt m,
           typename = std::enable_if_t<is_arithmetic<T>::value, void>>
 __device__ __host__ Matrix<decltype(DT(0) * T(0)), n, m>
 operator*(const T& b, const StaticMatrix<DT, ST, n, m>& a) {
   return a * b;
 }
 
 template <typename DT, typename ST, typename T, UInt n,
           typename = std::enable_if_t<is_arithmetic<T>::value>>
 __device__ __host__ SymMatrix<decltype(DT(0) * T(0)), n>
 operator*(const StaticSymMatrix<DT, ST, n>& a, const T& b) {
   SymMatrix<decltype(DT(0) * T(0)), n> res{a};
   res *= b;
   return res;
 }
 
 // symmetry
 template <typename DT, typename ST, typename T, UInt n,
           typename = std::enable_if_t<is_arithmetic<T>::value>>
 __device__ __host__ SymMatrix<decltype(DT(0) * T(0)), n>
 operator*(const T& b, const StaticSymMatrix<DT, ST, n>& a) {
   return a * b;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Linear algebra operators */
 /* -------------------------------------------------------------------------- */
 
 /// Matrix-vector multiplication
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n,
           UInt m>
 __device__ __host__ Vector<decltype(DT1(0) * DT2(0)), n>
 operator*(const StaticMatrix<DT1, ST1, n, m>& a,
           const StaticVector<DT2, ST2, m>& b) {
   Vector<decltype(DT1(0) * DT2(0)), n> res;
   res.template mul<false>(a, b);
   return res;
 }
 
 /// Matrix-matrix multiplication
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n,
           UInt m, UInt l>
 __device__ __host__ Matrix<decltype(DT1(0) * DT2(0)), n, m>
 operator*(const StaticMatrix<DT1, ST1, n, l>& a,
           const StaticMatrix<DT2, ST2, l, m>& b) {
   Matrix<decltype(DT1(0) * DT2(0)), n, m> res;
   res.mul(a, b);
   return res;
 }
 
 template <typename DT1, typename ST1, typename DT2, typename ST2, UInt n,
           UInt m>
 __device__ __host__ Matrix<decltype(DT1(0) * DT2(0)), n, m>
 outer(const StaticVector<DT1, ST1, n>& a, const StaticVector<DT2, ST2, m>& b) {
   Matrix<decltype(DT1(0) * DT2(0)), n, m> res;
   res.outer(a, b);
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Dense/Sparse */
 /* -------------------------------------------------------------------------- */
 template <typename DT, typename ST, UInt n>
 __device__ __host__ Matrix<std::remove_cv_t<DT>, n, n>
 dense(const StaticSymMatrix<DT, ST, n>& m) {
   Matrix<std::remove_cv_t<DT>, n, n> res;
   res.fromSymmetric(m);
   return res;
 }
 
 template <typename DT, typename ST, UInt n>
 __device__ __host__ auto dense(const StaticVector<DT, ST, n>& v)
     -> Vector<DT, n> {
   return v;
 }
 
 template <typename DT, typename ST, UInt n>
 __device__ __host__ SymMatrix<std::remove_cv_t<DT>, n>
 symmetrize(const StaticMatrix<DT, ST, n, n>& m) {
   SymMatrix<std::remove_cv_t<DT>, n> res;
   res.symmetrize(m);
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename DT, typename ST>
 __device__ __host__ Vector<std::remove_cv_t<DT>, 3>
 invariants(const StaticSymMatrix<DT, ST, 3>& m) {
   return {{// I1 = tr(A)
            m.trace(),
            // I2 = 1/2 * (tr(A)^2 - tr(A^2))
            m(0) * m(1) + m(1) * m(2) + m(0) * m(2) -
                0.5 * (m(3) * m(3) + m(4) * m(4) + m(5) * m(5)),
            // I3 = det(A)
            m(0) * m(1) * m(2) + m(5) * m(3) * m(4) / std::sqrt(2) -
                0.5 * (m(4) * m(4) * m(1) + m(3) * m(3) * m(0) +
                       m(5) * m(5) * m(2))}};
 }
 
 template <typename DT, typename ST>
 __device__ __host__ Vector<std::remove_cv_t<DT>, 3>
 eigenvalues(const StaticSymMatrix<DT, ST, 3>& m) {
   constexpr UInt n = 3;
   Vector<std::remove_cv_t<DT>, n> eigenv;
   auto inv = invariants(m);
   Real a = 1, b = -inv(0), c = inv(1), d = -inv(2);
   auto p = (3 * a * c - b * b) / (3 * a * a);
   auto q = (2 * b * b * b - 9 * a * b * c + 27 * a * a * d) / (27 * a * a * a);
 
   for (UInt k = 0; k < n; ++k)
     eigenv(k) =
         2. * std::sqrt(-p / 3.) *
             std::cos(1. / 3. *
                          std::acos(3. * q / (2. * p) * std::sqrt(-3. / p)) -
                      2. * M_PI * k / 3.) -
         b / (3. * a);
 
   // Sorting eigenvalues
   std::remove_cv_t<DT> max = eigenv(0);
   UInt max_k = 0;
   for (UInt k = 1; k < n; ++k) {
     if (eigenv(k) > max) {
       max = eigenv(k);
       max_k = k;
     }
   }
 
   thrust::swap(eigenv.back(), eigenv(max_k));
 
   if (eigenv(0) > eigenv(1))
     thrust::swap(eigenv(0), eigenv(1));
 
   return eigenv;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Type traits */
 /* -------------------------------------------------------------------------- */
 
 template <class Type>
 struct is_proxy : std::false_type {};
 
 template <template <typename, typename, UInt...> class StaticParent, typename T,
           UInt... dims>
 struct is_proxy<TensorProxy<StaticParent, T, dims...>> : std::true_type {};
 
 template <typename T, UInt n, UInt m>
 struct is_proxy<MatrixProxy<T, n, m>> : std::true_type {};
 
 template <typename T, UInt n>
 struct is_proxy<SymMatrixProxy<T, n>> : std::true_type {};
 
 template <typename T, UInt n>
 struct is_proxy<VectorProxy<T, n>> : std::true_type {};
 
 }  // namespace tamaas
 
 #endif  // STATIC_TYPES_HH
diff --git a/src/core/statistics.cpp b/src/core/statistics.cpp
index e466dc5..db5c3f3 100644
--- a/src/core/statistics.cpp
+++ b/src/core/statistics.cpp
@@ -1,249 +1,250 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "statistics.hh"
 #include "fft_engine.hh"
 #include "loop.hh"
 #include "static_types.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 template <UInt dim>
 Real Statistics<dim>::computeRMSHeights(Grid<Real, dim>& surface) {
   return std::sqrt(surface.var());
 }
 
 template <UInt dim>
 Real Statistics<dim>::computeSpectralRMSSlope(Grid<Real, dim>& surface) {
   const auto h_size =
       GridHermitian<Real, dim>::hermitianDimensions(surface.sizes());
   auto wavevectors =
       FFTEngine::template computeFrequencies<Real, dim, true>(h_size);
   wavevectors *= 2 * M_PI;  // need q for slopes
   const auto psd = computePowerSpectrum(surface);
 
   const Real rms_slope_mean = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(VectorProxy<const Real, dim> q, const Complex& psd_val) {
         // Checking if we're in the zone that does not have hermitian symmetry
         if (std::abs(q.back()) < 1e-15)
           return q.l2squared() * psd_val.real();
         return 2 * q.l2squared() * psd_val.real();
       },
       range<VectorProxy<const Real, dim>>(wavevectors), psd);
 
   return std::sqrt(rms_slope_mean);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 GridHermitian<Real, dim>
 Statistics<dim>::computePowerSpectrum(Grid<Real, dim>& surface) {
   const auto h_size =
       GridHermitian<Real, dim>::hermitianDimensions(surface.sizes());
   GridHermitian<Real, dim> psd(h_size, surface.getNbComponents());
 
   FFTEngine::makeEngine()->forward(surface, psd);
 
   Real factor = 1. / surface.getGlobalNbPoints();
 
   // Squaring the fourier transform of surface and normalizing
   Loop::loop(
       [factor] CUDA_LAMBDA(Complex & c) {
         c *= factor;
         c *= conj(c);
       },
       psd);
 
   return psd;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Grid<Real, dim>
 Statistics<dim>::computeAutocorrelation(Grid<Real, dim>& surface) {
   Grid<Real, dim> acf(surface.sizes(), surface.getNbComponents());
   auto psd = computePowerSpectrum(surface);
 
   FFTEngine::makeEngine()->backward(acf, psd);
   acf *= acf.getGlobalNbPoints();
   return acf;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 Real Statistics<dim>::contact(const Grid<Real, dim>& tractions,
                               UInt perimeter) {
   Real points = 0;
   UInt nc = tractions.getNbComponents();
 
   switch (nc) {
   case 1:
     points = Loop::reduce(
         [] CUDA_LAMBDA(const Real& t) -> Real { return t > 0; }, tractions);
     break;
   case 2:
     points = Loop::reduce(
         [] CUDA_LAMBDA(VectorProxy<const Real, 2> t) -> Real {
           return t.back() > 0;
         },
         range<VectorProxy<const Real, 2>>(tractions));
     break;
   case 3:
     points = Loop::reduce(
         [] CUDA_LAMBDA(VectorProxy<const Real, 3> t) -> Real {
           return t.back() > 0;
         },
         range<VectorProxy<const Real, 3>>(tractions));
     break;
   default:
     TAMAAS_EXCEPTION("Invalid number of components in traction");
   }
 
   auto area = points / tractions.getGlobalNbPoints();
 
   if (dim == 1)
     perimeter = 0;
 
   // Correction from Yastrebov et al. (Trib. Intl., 2017)
   // 10.1016/j.triboint.2017.04.023
   return area - (M_PI - 1 + std::log(2)) /
                     (24. * tractions.getGlobalNbPoints()) * perimeter;
 }
 
 /* -------------------------------------------------------------------------- */
 namespace {
 template <UInt dim>
 class moment_helper {
 public:
   moment_helper(const std::array<UInt, dim>& exp) : exponent(exp) {}
 
   CUDA_LAMBDA Complex operator()(VectorProxy<Real, dim> q,
                                  const Complex& phi) const {
     Real mul = 1;
     for (UInt i = 0; i < dim; ++i)
       mul *= std::pow(q(i), exponent[i]);
 
     // Do not duplicate everything from hermitian symmetry
     if (std::abs(q.back()) < 1e-15)
       return mul * phi;
     return 2 * mul * phi;
   }
 
 private:
   std::array<UInt, dim> exponent;
 };
 }  // namespace
 
 /* -------------------------------------------------------------------------- */
 template <>
 std::vector<Real> Statistics<1>::computeMoments(Grid<Real, 1>& surface) {
   constexpr UInt dim = 1;
   std::vector<Real> moments(3);
   const auto psd = computePowerSpectrum(surface);
   auto wavevectors =
       FFTEngine::template computeFrequencies<Real, dim, true>(psd.sizes());
   // we don't multiply by 2 pi because moments are computed with k
   moments[0] = Loop::reduce<operation::plus>(moment_helper<dim>{{{0}}},
                                              range<PVector>(wavevectors), psd)
                    .real();
   moments[1] = Loop::reduce<operation::plus>(moment_helper<dim>{{{2}}},
                                              range<PVector>(wavevectors), psd)
                    .real();
   moments[2] = Loop::reduce<operation::plus>(moment_helper<dim>{{{4}}},
                                              range<PVector>(wavevectors), psd)
                    .real();
   return moments;
 }
 
 template <>
 std::vector<Real> Statistics<2>::computeMoments(Grid<Real, 2>& surface) {
   constexpr UInt dim = 2;
   std::vector<Real> moments(3);
   const auto psd = computePowerSpectrum(surface);
   auto wavevectors =
       FFTEngine::template computeFrequencies<Real, dim, true>(psd.sizes());
   // we don't multiply by 2 pi because moments are computed with k
   moments[0] = Loop::reduce<operation::plus>(moment_helper<dim>{{{0, 0}}},
                                              range<PVector>(wavevectors), psd)
                    .real();
   auto m02 = Loop::reduce<operation::plus>(moment_helper<dim>{{{0, 2}}},
                                            range<PVector>(wavevectors), psd)
                  .real();
   auto m20 = Loop::reduce<operation::plus>(moment_helper<dim>{{{2, 0}}},
                                            range<PVector>(wavevectors), psd)
                  .real();
   moments[1] = (m02 + m20) / 2;
   auto m22 = Loop::reduce<operation::plus>(moment_helper<dim>{{{2, 2}}},
                                            range<PVector>(wavevectors), psd)
                  .real();
   auto m40 = Loop::reduce<operation::plus>(moment_helper<dim>{{{4, 0}}},
                                            range<PVector>(wavevectors), psd)
                  .real();
   auto m04 = Loop::reduce<operation::plus>(moment_helper<dim>{{{0, 4}}},
                                            range<PVector>(wavevectors), psd)
                  .real();
   moments[2] = (3 * m22 + m40 + m04) / 3;
   return moments;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 Real Statistics<dim>::graphArea(const Grid<Real, dim>& zdisplacement) {
   const auto h_size =
       GridHermitian<Real, dim>::hermitianDimensions(zdisplacement.sizes());
   GridHermitian<Real, dim> fourier_disp(h_size, 1),
       fourier_gradient(h_size, dim);
   Grid<Real, dim> gradient(zdisplacement.sizes(), dim);
 
   // Compute gradient in Fourier domain
   FFTEngine::makeEngine()->forward(zdisplacement, fourier_disp);
 
   auto wavevectors =
       FFTEngine::template computeFrequencies<Real, dim, true>(h_size);
   wavevectors *= 2 * M_PI;
 
   Loop::loop(
       [] CUDA_LAMBDA(VectorProxy<const Real, dim> q,
                      VectorProxy<Complex, dim> grad, const Complex& f) {
         grad = q * f;
         grad *= Complex{0, 1};
       },
       range<VectorProxy<const Real, dim>>(wavevectors),
       range<VectorProxy<Complex, dim>>(fourier_gradient), fourier_disp);
 
   FFTEngine::makeEngine()->backward(gradient, fourier_gradient);
 
   // Integrate area of graph formula
   Real factor = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(VectorProxy<const Real, dim> grad) {
         return std::sqrt(1 + grad.l2squared());
       },
       range<VectorProxy<const Real, dim>>(gradient));
   return factor / gradient.getGlobalNbPoints();
   // return 2 * M_PI * factor / gradient.getGlobalNbPoints();
 }
 
 template struct Statistics<1>;
 template struct Statistics<2>;
 
 }  // namespace tamaas
diff --git a/src/core/statistics.hh b/src/core/statistics.hh
index 93afcba..90f08a7 100644
--- a/src/core/statistics.hh
+++ b/src/core/statistics.hh
@@ -1,57 +1,58 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef STATISTICS_HH
 #define STATISTICS_HH
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "grid.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /**
  * @brief Suitcase class for all statistics related functions
  */
 template <UInt dim>
 struct Statistics {
   /// Compute hrms
   static Real computeRMSHeights(Grid<Real, dim>& surface);
   /// Compute hrms' in fourier space
   static Real computeSpectralRMSSlope(Grid<Real, dim>& surface);
   /// Compute PSD of surface
   static GridHermitian<Real, dim>
   computePowerSpectrum(Grid<Real, dim>& surface);
   /// Compute autocorrelation
   static Grid<Real, dim> computeAutocorrelation(Grid<Real, dim>& surface);
   /// Compute spectral moments
   static std::vector<Real> computeMoments(Grid<Real, dim>& surface);
   /// Compute (corrected) contact area fraction
   static Real contact(const Grid<Real, dim>& tractions, UInt perimeter = 0);
   /// Compute the area scaling factor of a periodic graph
   static Real graphArea(const Grid<Real, dim>& displacement);
 
   using PVector = VectorProxy<Real, dim>;
 };
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 #endif  // STATISTICS_HH
diff --git a/src/core/tamaas.cpp b/src/core/tamaas.cpp
index 3923187..35374f0 100644
--- a/src/core/tamaas.cpp
+++ b/src/core/tamaas.cpp
@@ -1,107 +1,108 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 #include "tamaas.hh"
 #include "fftw/interface.hh"
 #include "logger.hh"
 #include "mpi_interface.hh"
 #if TAMAAS_LOOP_BACKEND == TAMAAS_LOOP_BACKEND_OMP
 #include <omp.h>
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 void initialize(UInt num_threads) {
   static bool has_warned = false;
 
   mpi::thread provided = mpi::thread::single;
 
   if (not mpi::initialized()) {
     mpi::init_thread(nullptr, nullptr, mpi::thread::multiple, &provided);
   }
 
   bool should_init_threads = (provided > mpi::thread::single);
 
 #if TAMAAS_LOOP_BACKEND == TAMAAS_LOOP_BACKEND_OMP
   if (num_threads)
     omp_set_num_threads(num_threads);  // set user-defined number of threads
   else
     num_threads = omp_get_max_threads();
 #else
   if (num_threads != 0)
     num_threads = 1;
 #endif
 
 #if TAMAAS_FFTW_BACKEND != TAMAAS_FFTW_BACKEND_NONE
   if (should_init_threads and (not fftw::init_threads())) {
     TAMAAS_EXCEPTION("FFTW could not initialize threads!");
   } else if (not should_init_threads)
     Logger().get(LogLevel::debug) << "not initializing FFTW threads\n";
 #endif
 
   if (mpi::initialized()) {
     if (not has_warned) {
       Logger().get(LogLevel::warning) << "experimental MPI support\n";
       has_warned = true;
     }
     fftw::mpi::init();
   }
 
   if (should_init_threads) {
 #if TAMAAS_FFTW_BACKEND != TAMAAS_FFTW_BACKEND_NONE
     Logger().get(LogLevel::debug)
         << "initializing FFTW with " << num_threads << " threads\n";
     fftw::plan_with_nthreads(num_threads);
 #endif
   }
 
 #ifdef TAMAAS_USE_CUDA
   Logger().get(LogLevel::warning) << "experimental Cuda support\n";
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
 void finalize() {
   if (not mpi::finalized()) {
 #if TAMAAS_BACKEND != TAMAAS_BACKEND_CPP
     fftw::cleanup_threads();
 #endif
     fftw::mpi::cleanup();
     mpi::finalize();
   }
 }
 
 namespace {
 /// Manager for initialize + finalize
 struct entry_exit_points {
   entry_exit_points() { initialize(); }
   ~entry_exit_points() { finalize(); }
   static const entry_exit_points singleton;
 };
 
 const entry_exit_points entry_exit_points::singleton;
 }  // namespace
 
 }  // namespace tamaas
diff --git a/src/core/tamaas.hh b/src/core/tamaas.hh
index 2aa48aa..1f15e61 100644
--- a/src/core/tamaas.hh
+++ b/src/core/tamaas.hh
@@ -1,198 +1,199 @@
 /**
  *  @mainpage Tamaas - A high-performance periodic contact library
  *
  *  @section Introduction
  *  Tamaas is a spectral-integral-equation based contact library. It is made
  *  with love to be fast and friendly!
  *
  *  @author Lucas Frérot <lfrerot1@jhu.edu>
  *  @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *  @author Valentine Rey <valentine.rey@univ-nantes.fr>
  *  @author Son Pham-Ba <son.phamba@epfl.ch>
  *  @author Jean-François Molinari <jean-francois.molinari@epfl.ch>
  *
  *  @section License
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef TAMAAS_HH
 #define TAMAAS_HH
 /* -------------------------------------------------------------------------- */
 
 #ifndef TAMAAS_USE_CUDA
 #define TAMAAS_USE_FFTW
 #endif
 
 // Values for fftw backends
 #define TAMAAS_FFTW_BACKEND_OMP 2
 #define TAMAAS_FFTW_BACKEND_THREADS 2
 #define TAMAAS_FFTW_BACKEND_NONE 3
 // Values for thrust backends
 #define TAMAAS_LOOP_BACKEND_OMP 1
 #define TAMAAS_LOOP_BACKEND_TBB 2
 #define TAMAAS_LOOP_BACKEND_CPP 3
 #define TAMAAS_LOOP_BACKEND_CUDA 4
 // Default loop backend is OpenMP
 #ifndef TAMAAS_LOOP_BACKEND
 #define TAMAAS_LOOP_BACKEND TAMAAS_LOOP_BACKEND_OMP
 #endif
 // Default FFTW backend is none
 #ifndef TAMAAS_FFTW_BACKEND
 #define TAMAAS_FFTW_BACKEND TAMAAS_FFTW_BACKEND_NONE
 #endif
 // If the thrust device hasn't been set, set OpenMP
 #ifndef THRUST_DEVICE_SYSTEM
 #define THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_OMP
 #endif
 /* -------------------------------------------------------------------------- */
 // Standard includes
 #include <exception>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 // Special thrust includes
 #include <thrust/complex.h>
 #include <thrust/random.h>
 
 #ifdef TAMAAS_USE_CUDA
 #include "cuda/unified_allocator.hh"
 #else
 #include "fftw/fftw_allocator.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /// Cuda specific definitions
 #define CUDA_LAMBDA __device__ __host__
 
 #ifdef TAMAAS_USE_CUDA
 template <typename T>
 using Allocator = UnifiedAllocator<T>;
 #else
 template <typename T>
 using Allocator = FFTWAllocator<T>;
 #endif
 
 /// Common types definitions
 // If type macros have not been set, put default values
 #ifndef TAMAAS_REAL_TYPE
 #define TAMAAS_REAL_TYPE double
 #endif
 #ifndef TAMAAS_INT_TYPE
 #define TAMAAS_INT_TYPE int
 #endif
 
 using Real = TAMAAS_REAL_TYPE;           ///< default floating point type
 using Int = TAMAAS_INT_TYPE;             ///< default signed integer type
 using UInt = std::make_unsigned_t<Int>;  ///< default unsigned integer type
 template <typename T>
 using complex = thrust::complex<T>;  ///< template complex wrapper
 using Complex = complex<Real>;       ///< default floating point complex type
 
 /// Defining random toolbox
 using ::thrust::random::normal_distribution;
 using ::thrust::random::uniform_real_distribution;
 using random_engine = ::thrust::random::default_random_engine;
 
 namespace detail {
 template <bool acc, template <typename> class Trait, typename Head,
           typename... Tail>
 struct fold_trait_tail_rec
     : std::integral_constant<bool,
                              fold_trait_tail_rec<acc and Trait<Head>::value,
                                                  Trait, Tail...>::value> {};
 
 template <bool acc, template <typename> class Trait, typename Head>
 struct fold_trait_tail_rec<acc, Trait, Head>
     : std::integral_constant<bool, acc and Trait<Head>::value> {};
 }  // namespace detail
 
 template <template <typename> class Trait, typename... T>
 struct fold_trait : detail::fold_trait_tail_rec<true, Trait, T...> {};
 
 /* -------------------------------------------------------------------------- */
 /// initialize tamaas (0 threads => let OMP_NUM_THREADS decide)
 void initialize(UInt num_threads = 0);
 /// cleanup tamaas
 void finalize();
 /* -------------------------------------------------------------------------- */
 
 /// CUDA-compatible exchange function
 template <class U, class V = U>
 __device__ __host__ U exchange(U& obj, V&& new_value) {
   U old_value = std::move(obj);
   obj = std::forward<V>(new_value);
   return old_value;
 }
 
 /// Generic exception class
 class Exception : public std::exception {
 public:
   /// Constructor
   Exception(std::string mesg) : msg(std::move(mesg)) {}
 
   const char* what() const noexcept override { return msg.c_str(); }
 
   ~Exception() override = default;
 
 private:
   std::string msg;  ///< message of exception
 };
 /* -------------------------------------------------------------------------- */
 /// Enumeration of reduction operations
 enum class operation { plus, times, min, max };
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 
 /// Convenience macros
 #define TAMAAS_DEBUG_MSG(mesg)                                                 \
   __FILE__ << ':' << __LINE__ << ": " << mesg << '\n'
 #define TAMAAS_EXCEPTION(mesg)                                                 \
   {                                                                            \
     std::stringstream sstr;                                                    \
     sstr << TAMAAS_DEBUG_MSG("FATAL: " << mesg);                               \
     throw ::tamaas::Exception(sstr.str());                                     \
   }
 
 #define SURFACE_FATAL(mesg) TAMAAS_EXCEPTION(mesg)
 
 #if defined(TAMAAS_DEBUG)
 #define TAMAAS_ASSERT(cond, reason)                                            \
   do {                                                                         \
     if (not(cond)) {                                                           \
       TAMAAS_EXCEPTION(#cond " assert failed: " << reason);                    \
     }                                                                          \
   } while (0)
 #define TAMAAS_DEBUG_EXCEPTION(reason) TAMAAS_EXCEPTION(reason)
 #else
 #define TAMAAS_ASSERT(cond, reason)
 #define TAMAAS_DEBUG_EXCEPTION(reason)
 #endif
 #define TAMAAS_ACCESSOR(var, type, name)                                       \
   type& get##name() { return var; }                                            \
   void set##name(const type& new_var) { var = new_var; }
 
 /* -------------------------------------------------------------------------- */
 
 #endif  // TAMAAS_HH
diff --git a/src/model/adhesion_functional.cpp b/src/model/adhesion_functional.cpp
index 61172f4..3166eaf 100644
--- a/src/model/adhesion_functional.cpp
+++ b/src/model/adhesion_functional.cpp
@@ -1,107 +1,108 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "adhesion_functional.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace functional {
 
 Real ExponentialAdhesionFunctional::computeF(
     GridBase<Real>& gap, GridBase<Real>& /*pressure*/) const {
   auto rho_inv = 1. / getParameters().at("rho");
   auto gamma = getParameters().at("surface_energy");
 
   return -gamma * Loop::reduce<operation::plus>(
                       [rho_inv] CUDA_LAMBDA(const Real& g) {
                         return std::exp(-g * rho_inv);
                       },
                       gap);
 }
 
 void ExponentialAdhesionFunctional::computeGradF(
     GridBase<Real>& gap, GridBase<Real>& gradient) const {
   auto rho_inv = 1. / getParameters().at("rho");
   auto gamma = getParameters().at("surface_energy");
 
   Loop::loop(
       [rho_inv, gamma] CUDA_LAMBDA(const Real& g, Real& grad) {
         grad += gamma * std::exp(-g * rho_inv) * rho_inv;
       },
       gap, gradient);
 }
 
 Real MaugisAdhesionFunctional::computeF(GridBase<Real>& gap,
                                         GridBase<Real>& /*pressure*/) const {
   auto rho = getParameters().at("rho");
   auto rho_inv = 1. / rho;
   auto gamma = getParameters().at("surface_energy");
 
   return -gamma * Loop::reduce<operation::plus>(
                       [rho, rho_inv] CUDA_LAMBDA(const Real& g) {
                         return (g > rho) ? 0 : 1 - g * rho_inv;
                       },
                       gap);
 }
 
 void MaugisAdhesionFunctional::computeGradF(GridBase<Real>& gap,
                                             GridBase<Real>& gradient) const {
   auto rho = getParameters().at("rho");
   auto rho_inv = 1. / rho;
   auto gamma = getParameters().at("surface_energy");
 
   Loop::loop(
       [rho, rho_inv, gamma] CUDA_LAMBDA(const Real& g, Real& grad) {
         grad += (g > rho) ? 0 : gamma * rho_inv;
       },
       gap, gradient);
 }
 
 Real SquaredExponentialAdhesionFunctional::computeF(
     GridBase<Real>& gap, GridBase<Real>& /*pressure*/) const {
   auto rho_inv = 1. / getParameters().at("rho");
   auto rho_inv_2 = rho_inv * rho_inv;
   auto gamma = getParameters().at("surface_energy");
 
   return -gamma * Loop::reduce<operation::plus>(
                       [rho_inv_2] CUDA_LAMBDA(const Real& g) {
                         return std::exp(-0.5 * g * g * rho_inv_2);
                       },
                       gap);
 }
 
 void SquaredExponentialAdhesionFunctional::computeGradF(
     GridBase<Real>& gap, GridBase<Real>& gradient) const {
   auto rho_inv = 1. / getParameters().at("rho");
   auto rho_inv_2 = rho_inv * rho_inv;
   auto gamma = getParameters().at("surface_energy");
 
   Loop::loop(
       [rho_inv_2, gamma] CUDA_LAMBDA(const Real& g, Real& grad) {
         grad += g * rho_inv_2 * gamma * std::exp(-0.5 * g * g * rho_inv_2);
       },
       gap, gradient);
 }
 
 }  // namespace functional
 
 }  // namespace tamaas
diff --git a/src/model/adhesion_functional.hh b/src/model/adhesion_functional.hh
index 558b3ad..21942f7 100644
--- a/src/model/adhesion_functional.hh
+++ b/src/model/adhesion_functional.hh
@@ -1,99 +1,100 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ADHESION_FUNCTIONAL_HH
 #define ADHESION_FUNCTIONAL_HH
 /* -------------------------------------------------------------------------- */
 #include "functional.hh"
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace functional {
 
 /// Functional class for adhesion energy
 class AdhesionFunctional : public Functional {
 protected:
   /// Constructor
   AdhesionFunctional(const GridBase<Real>& surface) {
     this->surface.wrap(surface);
   }
 
 public:
   /// Get parameters
   const std::map<std::string, Real>& getParameters() const {
     return parameters;
   }
   /// Set parameters
   void setParameters(std::map<std::string, Real> other) {
     parameters = std::move(other);
   }
 
 protected:
   GridBase<Real> surface;
   std::map<std::string, Real> parameters;
 };
 
 /// Exponential adhesion functional
 class ExponentialAdhesionFunctional : public AdhesionFunctional {
 public:
   /// Explicit declaration of constructor for swig
   ExponentialAdhesionFunctional(const GridBase<Real>& surface)
       : AdhesionFunctional(surface) {}
   /// Compute the total adhesion energy
   Real computeF(GridBase<Real>& gap, GridBase<Real>& pressure) const override;
   /// Compute the gradient of the adhesion functional
   void computeGradF(GridBase<Real>& gap,
                     GridBase<Real>& gradient) const override;
 };
 
 /// Constant adhesion functional
 class MaugisAdhesionFunctional : public AdhesionFunctional {
 public:
   /// Explicit declaration of constructor for swig
   MaugisAdhesionFunctional(const GridBase<Real>& surface)
       : AdhesionFunctional(surface) {}
   /// Compute the total adhesion energy
   Real computeF(GridBase<Real>& gap, GridBase<Real>& pressure) const override;
   /// Compute the gradient of the adhesion functional
   void computeGradF(GridBase<Real>& gap,
                     GridBase<Real>& gradient) const override;
 };
 
 /// Squared exponential adhesion functional
 class SquaredExponentialAdhesionFunctional : public AdhesionFunctional {
 public:
   /// Explicit declaration of constructor for swig
   SquaredExponentialAdhesionFunctional(const GridBase<Real>& surface)
       : AdhesionFunctional(surface) {}
   /// Compute the total adhesion energy
   Real computeF(GridBase<Real>& gap, GridBase<Real>& pressure) const override;
   /// Compute the gradient of the adhesion functional
   void computeGradF(GridBase<Real>& gap,
                     GridBase<Real>& gradient) const override;
 };
 
 }  // namespace functional
 
 }  // namespace tamaas
 
 #endif  // ADHESION_FUNCTIONAL_HH
diff --git a/src/model/be_engine.cpp b/src/model/be_engine.cpp
index e401eaa..f3706a5 100644
--- a/src/model/be_engine.cpp
+++ b/src/model/be_engine.cpp
@@ -1,88 +1,89 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "be_engine.hh"
 #include "logger.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 void solve(IntegralOperator::kind kind,
            const std::map<IntegralOperator::kind, IntegralOperator*>& operators,
            GridBase<Real>& input, GridBase<Real>& output) try {
   operators.at(kind)->apply(input, output);
 } catch (std::out_of_range& e) {
   Logger().get(LogLevel::warning)
       << "Operator ("
       << "Westergaard::" << kind << ") not registered\n";
   throw e;
 }
 
 template <model_type mtype, IntegralOperator::kind otype>
 void registerWestergaardOperator(
     std::map<IntegralOperator::kind, IntegralOperator*>& operators,
     Model& model) {
   std::stringstream sstr;
   sstr << "Westergaard::" << otype;
   if (operators.find(otype) == operators.end())
     operators[otype] =
         model.template registerIntegralOperator<Westergaard<mtype, otype>>(
             sstr.str());
 }
 
 template <model_type type>
 void BEEngineTmpl<type>::solveNeumann(GridBase<Real>& neumann,
                                       GridBase<Real>& dirichlet) const {
   solve(IntegralOperator::neumann, this->operators, neumann, dirichlet);
 }
 
 template <model_type type>
 void BEEngineTmpl<type>::solveDirichlet(GridBase<Real>& dirichlet,
                                         GridBase<Real>& neumann) const {
   solve(IntegralOperator::dirichlet, this->operators, dirichlet, neumann);
 }
 
 template <model_type type>
 void BEEngineTmpl<type>::registerNeumann() {
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("Registering Neumann Westergaard");
   registerWestergaardOperator<type, IntegralOperator::neumann>(this->operators,
                                                                *this->model);
 }
 /// Register dirichlet operator
 template <model_type type>
 void BEEngineTmpl<type>::registerDirichlet() {
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("Registering Dirichlet Westergaard");
   registerWestergaardOperator<type, IntegralOperator::dirichlet>(
       this->operators, *this->model);
 }
 
 template class BEEngineTmpl<model_type::basic_1d>;
 template class BEEngineTmpl<model_type::basic_2d>;
 template class BEEngineTmpl<model_type::surface_1d>;
 template class BEEngineTmpl<model_type::surface_2d>;
 template class BEEngineTmpl<model_type::volume_1d>;
 template class BEEngineTmpl<model_type::volume_2d>;
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/model/be_engine.hh b/src/model/be_engine.hh
index e5d7718..6beae41 100644
--- a/src/model/be_engine.hh
+++ b/src/model/be_engine.hh
@@ -1,86 +1,87 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef BE_ENGINE_HH
 #define BE_ENGINE_HH
 /* -------------------------------------------------------------------------- */
 #include "model_type.hh"
 #include "integral_operator.hh"
 #include "westergaard.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Boundary equation engine class. Solves the Neumann/Dirichlet problem
  * This class should be dimension and model-type agnostic.
  */
 class BEEngine {
 public:
   BEEngine(Model* model) : model(model) {}
   /// Destructor
   virtual ~BEEngine() = default;
 
 public:
   /// Solve Neumann problem (expects boundary data)
   virtual void solveNeumann(GridBase<Real>& neumann,
                             GridBase<Real>& dirichlet) const = 0;
   /// Solve Dirichlet problem (expects boundary data)
   virtual void solveDirichlet(GridBase<Real>& dirichlet,
                               GridBase<Real>& neumann) const = 0;
 
   /// Register neumann operator
   virtual void registerNeumann() = 0;
   /// Register dirichlet operator
   virtual void registerDirichlet() = 0;
 
   /// Get model
   const Model& getModel() const { return *model; }
 
   /// Compute L_2 norm of influence functions
   Real getNeumannNorm() {
     return operators[IntegralOperator::neumann]->getOperatorNorm();
   }
 
 protected:
   Model* model;
   std::map<IntegralOperator::kind, IntegralOperator*> operators;
 };
 
 template <model_type type>
 class BEEngineTmpl : public BEEngine {
 public:
   BEEngineTmpl(Model* model): BEEngine(model) {}
 
   void solveNeumann(GridBase<Real>& neumann,
 		    GridBase<Real>& dirichlet) const override;
   void solveDirichlet(GridBase<Real>& dirichlet,
                       GridBase<Real>& neumann) const override;
   /// Register neumann operator
   void registerNeumann() override;
   /// Register dirichlet operator
   void registerDirichlet() override;
 
 };
 
 }  // namespace tamaas
 
 #endif  // BE_ENGINE_HH
diff --git a/src/model/boussinesq.cpp b/src/model/boussinesq.cpp
index cb96a35..de3e097 100644
--- a/src/model/boussinesq.cpp
+++ b/src/model/boussinesq.cpp
@@ -1,98 +1,99 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "boussinesq.hh"
 #include "boussinesq_helper.hh"
 #include "influence.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /// \cond DO_NOT_DOCUMENT
 template <>
 Boussinesq<model_type::volume_2d, 0>::Boussinesq(Model* model) : parent(model) {
   this->initialize(trait::dimension, trait::dimension);
 }
 
 template <>
 Boussinesq<model_type::volume_2d, 1>::Boussinesq(Model* model) : parent(model) {
   this->initialize(trait::dimension, trait::voigt);
 }
 /// \endcond
 
 /* -------------------------------------------------------------------------- */
 /* Operator implementation */
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 void Boussinesq<type, derivative>::apply(GridBase<Real>& source,
                                          GridBase<Real>& out) const {
   Real nu = this->model->getPoissonRatio(), mu = this->model->getShearModulus();
   influence::Boussinesq<trait::dimension, derivative> boussinesq(mu, nu);
   influence::ElasticHelper<trait::dimension> el(mu, nu);
   detail::BoussinesqHelper<type, decltype(boussinesq)> helper;
 
   // the source is a Grid<Real, bdim> grid normally, so we gotta make sure we
   // can cast it into a Grid<Real, dim>
   GridView<Grid, Real, trait::boundary_dimension, trait::dimension> view(
       source, {}, -1);
 
   parent::transformSource(view);
 
   helper.template apply<true>(this->source_buffer.front(), this->out_buffer,
                               this->wavevectors,
                               this->model->getSystemSize().front(), boussinesq);
   helper.makeFundamentalModeGreatAgain(this->source_buffer.front(),
                                        this->out_buffer, el);
 
   parent::transformOutput(
       [](auto&& out_buffer, auto layer) ->
       typename parent::BufferType& { return out_buffer[layer]; },
       out);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 void Boussinesq<type, derivative>::initialize(UInt source_components,
                                               UInt out_components) {
   auto hermitian_sizes =
       GridHermitian<Real, trait::boundary_dimension>::hermitianDimensions(
           this->model->getBoundaryDiscretization());
 
   // Initializing buffers
   this->source_buffer.resize(1);
   this->out_buffer.resize(this->model->getDiscretization()[0]);
 
   // Resizing source buffer
   std::for_each(this->source_buffer.begin(), this->source_buffer.end(),
                 [&](auto& buffer) {
                   buffer.setNbComponents(source_components);
                   buffer.resize(hermitian_sizes);
                 });
 
   // Resizing output buffer
   std::for_each(this->out_buffer.begin(), this->out_buffer.end(),
                 [&](auto& buffer) {
                   buffer.setNbComponents(out_components);
                   buffer.resize(hermitian_sizes);
                 });
 }
 }  // namespace tamaas
diff --git a/src/model/boussinesq.hh b/src/model/boussinesq.hh
index 60f7498..10e17b9 100644
--- a/src/model/boussinesq.hh
+++ b/src/model/boussinesq.hh
@@ -1,55 +1,56 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef BOUSSINESQ_HH
 #define BOUSSINESQ_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_hermitian.hh"
 #include "model_type.hh"
 #include "volume_potential.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /**
  * @brief Boussinesq tensor
  */
 template <model_type type, UInt derivative>
 class Boussinesq : public VolumePotential<type> {
   static_assert(type == model_type::volume_1d || type == model_type::volume_2d,
                 "Only volume types are supported");
   using trait = model_type_traits<type>;
   using parent = VolumePotential<type>;
 
 public:
   /// Constructor
   Boussinesq(Model* model);
 
 protected:
   void initialize(UInt source_components, UInt out_components);
 
 public:
   /// Apply the Boussinesq operator
   void apply(GridBase<Real>& source, GridBase<Real>& out) const override;
 };
 
 }  // namespace tamaas
 
 #endif  // BOUSSINESQ_HH
diff --git a/src/model/boussinesq_helper.hh b/src/model/boussinesq_helper.hh
index 689c635..660784a 100644
--- a/src/model/boussinesq_helper.hh
+++ b/src/model/boussinesq_helper.hh
@@ -1,136 +1,137 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef BOUSSINESQ_HELPER_HH
 #define BOUSSINESQ_HELPER_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include "influence.hh"
 #include "integration/accumulator.hh"
 #include "kelvin_helper.hh"
 #include "model.hh"
 #include "model_type.hh"
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace detail {
 template <model_type type, typename boussinesq_t>
 struct BoussinesqHelper {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
   static constexpr UInt bdim = trait::boundary_dimension;
 
   using BufferType = GridHermitian<Real, bdim>;
   using source_t = typename KelvinTrait<boussinesq_t>::source_t;
   using out_t = typename KelvinTrait<boussinesq_t>::out_t;
 
   template <bool apply_q_power>
   void apply(BufferType& tractions, std::vector<BufferType>& out,
              const Grid<Real, bdim>& wavevectors, Real domain_size,
              const boussinesq_t& boussinesq) {
     for (UInt l : Loop::range(out.size()))
       apply<apply_q_power>(tractions, out[l], l, wavevectors, out.size(),
                            domain_size, boussinesq);
   }
 
   template <bool apply_q_power>
   void apply(BufferType& tractions, BufferType& out, UInt layer,
              const Grid<Real, bdim>& wavevectors, UInt discretization,
              Real domain_size, const boussinesq_t& boussinesq) {
     accumulator.makeUniformMesh(discretization, domain_size);
     const auto xl = accumulator.nodePositions()[layer];
     Loop::loop(
         [xl, boussinesq] CUDA_LAMBDA(VectorProxy<const Real, bdim> qv, out_t u,
                                      source_t t) {
           const auto q = qv.l2norm();
           const auto e = std::exp(-q * xl);
 
           // g0 part
           auto tmp = boussinesq.template applyU0<apply_q_power>(t, qv);
           tmp *= e;
           u += tmp;
 
           // g1 part
           tmp = boussinesq.template applyU1<apply_q_power>(t, qv);
           tmp *= q * xl * e;
           u += tmp;
         },
         range<VectorProxy<const Real, bdim>>(wavevectors).headless(),
         range<out_t>(out).headless(), range<source_t>(tractions).headless());
   }
 
   // add constant term if necessary
   void makeFundamentalModeGreatAgain(BufferType& /*tractions*/,
                                      std::vector<BufferType>& /*out*/,
                                      influence::ElasticHelper<dim>& /*el*/) {}
 
   // add constant term to a single layer
   template <typename ST>
   void makeFundamentalModeGreatAgain(StaticVector<Complex, ST, dim>& /*t*/,
                                      out_t& /*u*/,
                                      influence::ElasticHelper<dim>& /*el*/) {}
 
 protected:
   Accumulator<type, source_t> accumulator;  ///< really only here for mesh
 };
 
 /// \cond DO_NOT_DOCUMENT
 template <>
 template <typename ST>
 inline void
 BoussinesqHelper<model_type::volume_2d, influence::Boussinesq<3, 1>>::
     makeFundamentalModeGreatAgain(StaticVector<Complex, ST, dim>& t, out_t& u,
                                   influence::ElasticHelper<dim>& el) {
   if (mpi::rank() != 0)
     return;
 
   Matrix<Complex, 3, 3> correction({0, 0, 0, 0, 0, 0, -t(0) / el.mu,
                                     -t(1) / el.mu,
                                     -t(2) / (el.lambda + 2 * el.mu)});
   u.symmetrize(correction);
 }
 
 template <>
 inline void
 BoussinesqHelper<model_type::volume_2d, influence::Boussinesq<3, 1>>::
     makeFundamentalModeGreatAgain(BufferType& tractions,
                                   std::vector<BufferType>& out,
                                   influence::ElasticHelper<dim>& el) {
   if (mpi::rank() != 0)
     return;
 
   VectorProxy<Complex, dim> t(&tractions(0));
   for (auto&& grid : out) {
     out_t u(&grid(0));
     makeFundamentalModeGreatAgain(t, u, el);
   }
 }
 /// \endcond
 
 }  // namespace detail
 }  // namespace tamaas
 
 #endif  // BOUSSINESQ_HELPER_HH
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/model/elastic_functional.cpp b/src/model/elastic_functional.cpp
index 29c9e92..73773c3 100644
--- a/src/model/elastic_functional.cpp
+++ b/src/model/elastic_functional.cpp
@@ -1,71 +1,72 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "elastic_functional.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace functional {
 
 Real ElasticFunctionalPressure::computeF(GridBase<Real>& pressure,
                                          GridBase<Real>& dual) const {
   // This doesn't work if dual is multi-component
   *buffer = dual;
   // this can get large
   const unsigned long long n = dual.getGlobalNbPoints();
   return (pressure.dot(*buffer) / 2 - pressure.dot(surface)) / n;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void ElasticFunctionalPressure::computeGradF(GridBase<Real>& pressure,
                                              GridBase<Real>& gradient) const {
   this->op.apply(pressure, *buffer);
   // This doesn't work if dual is multi-component
   *buffer -= surface;
   gradient += *buffer;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real ElasticFunctionalGap::computeF(GridBase<Real>& gap,
                                     GridBase<Real>& dual) const {
   // This doesn't work if dual is multi-component
   *buffer = gap;
   *buffer += surface;
   const UInt n = dual.getGlobalNbPoints();
   const Real F = 0.5 * buffer->dot(dual);
   return F / n;  // avoid integer overflow
 }
 
 /* -------------------------------------------------------------------------- */
 
 void ElasticFunctionalGap::computeGradF(GridBase<Real>& gap,
                                         GridBase<Real>& gradient) const {
   *buffer = gap;
   *buffer += surface;  // Now we have displacements
   this->op.apply(*buffer, *buffer);
   gradient += *buffer;
 }
 
 }  // namespace functional
 
 }  // namespace tamaas
diff --git a/src/model/elastic_functional.hh b/src/model/elastic_functional.hh
index 031c8a3..26acb16 100644
--- a/src/model/elastic_functional.hh
+++ b/src/model/elastic_functional.hh
@@ -1,80 +1,81 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ELASTIC_FUNCTIONAL_HH
 #define ELASTIC_FUNCTIONAL_HH
 /* -------------------------------------------------------------------------- */
 #include "functional.hh"
 #include "model.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace functional {
 
 /// Generic functional for elastic energy
 class ElasticFunctional : public Functional {
 public:
   ElasticFunctional(const IntegralOperator& op, const GridBase<Real>& surface)
       : op(op), surface() {
     this->surface.wrap(surface);
     const Model& model = op.getModel();
     buffer = allocateGrid<true, Real>(op.getType(),
                                       model.getBoundaryDiscretization());
   }
 
 protected:
   const IntegralOperator& op;
   GridBase<Real> surface;
   std::unique_ptr<GridBase<Real>> mutable buffer;
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Functional with pressure as primal field
 class ElasticFunctionalPressure : public ElasticFunctional {
 public:
   using ElasticFunctional::ElasticFunctional;
   /// Compute functional with input pressure
   Real computeF(GridBase<Real>& pressure, GridBase<Real>& dual) const override;
   /// Compute functional gradient with input pressure
   void computeGradF(GridBase<Real>& pressure,
                     GridBase<Real>& gradient) const override;
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Functional with gap as primal field
 class ElasticFunctionalGap : public ElasticFunctional {
 public:
   using ElasticFunctional::ElasticFunctional;
   /// Compute functional with input gap
   Real computeF(GridBase<Real>& gap, GridBase<Real>& dual) const override;
   /// Compute functional gradient with input gap
   void computeGradF(GridBase<Real>& gap,
                     GridBase<Real>& gradient) const override;
 };
 
 }  // namespace functional
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // ELASTIC_FUNCTIONAL_HH
diff --git a/src/model/elasto_plastic/isotropic_hardening.cpp b/src/model/elasto_plastic/isotropic_hardening.cpp
index 88d295a..2977768 100644
--- a/src/model/elasto_plastic/isotropic_hardening.cpp
+++ b/src/model/elasto_plastic/isotropic_hardening.cpp
@@ -1,98 +1,99 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "isotropic_hardening.hh"
 #include "influence.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 IsotropicHardening<type>::IsotropicHardening(Model* model, Real sigma_0, Real h)
     : model(model), sigma_0(sigma_0), h(h) {
   plastic_strain =
       allocateGrid<type, false, Real>(model->getDiscretization(), trait::voigt);
   cumulated_plastic_strain =
       allocateGrid<type, false, Real>(model->getDiscretization(), 1);
   model->registerField("plastic_strain", plastic_strain);
   model->registerField("cumulated_plastic_strain", cumulated_plastic_strain);
 }
 
 /* -------------------------------------------------------------------------- */
 /// \cond DO_NOT_DOCUMENT
 template <>
 void IsotropicHardening<model_type::volume_2d>::applyTangentIncrement(
     Grid<Real, dim>& output, const Grid<Real, dim>& input,
     const Grid<Real, dim>& strain,
     const Grid<Real, dim>& strain_increment) const {
   const influence::ElasticHelper<dim> elasticity(
       this->model->getShearModulus(), this->model->getPoissonRatio());
 
   using pmatrix = SymMatrixProxy<Real, dim>;
   using cpmatrix = SymMatrixProxy<const Real, dim>;
 
   Real sigma_0 = this->sigma_0, h = this->h;  // for captures
 
   Loop::loop(
       [elasticity, sigma_0,
        h] CUDA_LAMBDA(pmatrix out, cpmatrix in, cpmatrix epsilon,
                       cpmatrix delta_epsilon, cpmatrix ep, const Real& p) {
         auto sigma_tr = elasticity(epsilon - ep + delta_epsilon);
 
         decltype(sigma_tr) dev;
         dev.deviatoric(sigma_tr, 3);
 
         auto von_mises = std::sqrt(1.5) * dev.l2norm();
 
         if (von_mises - IsotropicHardening<model_type::volume_2d>::hardening(
                             p, h, sigma_0) >
             0) {
           Real dp =
               (von_mises - IsotropicHardening<model_type::volume_2d>::hardening(
                                p, h, sigma_0)) /
               (3 * elasticity.mu + h);
           // Applying tangent from Bonnet & Frangi, p.175
 
           const Real beta = 3 * elasticity.mu * dp / von_mises;
           const Real gamma = 3 * elasticity.mu / (3 * elasticity.mu + h);
 
           const Real dot = dev.dot(in);
           dev *= 3 * elasticity.mu * (gamma - beta) * dot /
                  (von_mises * von_mises);
 
           out.deviatoric(in);
           out *= 2 * elasticity.mu * beta;
           out += dev;
         } else
           out = 0;
       },
       range<pmatrix>(output), range<cpmatrix>(input), range<cpmatrix>(strain),
       range<cpmatrix>(strain_increment), range<cpmatrix>(*this->plastic_strain),
       *this->cumulated_plastic_strain);
 }
 /// \endcond
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation */
 /* -------------------------------------------------------------------------- */
 template class IsotropicHardening<model_type::volume_2d>;
 
 }  // namespace tamaas
diff --git a/src/model/elasto_plastic/isotropic_hardening.hh b/src/model/elasto_plastic/isotropic_hardening.hh
index 8d9b59e..4625013 100644
--- a/src/model/elasto_plastic/isotropic_hardening.hh
+++ b/src/model/elasto_plastic/isotropic_hardening.hh
@@ -1,183 +1,184 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ISOTROPIC_HARDENING_HH
 #define ISOTROPIC_HARDENING_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "influence.hh"
 #include "model.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 class IsotropicHardening {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
 
 public:
   /// Constructor
   IsotropicHardening(Model* model, Real sigma_0, Real h);
 
   /// Compute plastic strain increment with radial return algorithm
   template <bool update>
   void computePlasticIncrement(Grid<Real, dim>& increment,
                                const Grid<Real, dim>& strain,
                                const Grid<Real, dim>& strain_increment);
 
   /// Compute stress
   template <bool update>
   void computeStress(Grid<Real, dim>& stress, const Grid<Real, dim>& strain,
                      const Grid<Real, dim>& strain_increment);
 
   void applyTangentIncrement(Grid<Real, dim>& output,
                              const Grid<Real, dim>& input,
                              const Grid<Real, dim>& strain,
                              const Grid<Real, dim>& strain_increment) const;
 
   static __device__ __host__ Real hardening(Real p, Real h, Real sigma_0) {
     return sigma_0 + h * p;
   }
 
   Real getHardeningModulus() const { return h; }
   Real getYieldStress() const { return sigma_0; }
   void setHardeningModulus(Real h_) {
     if (h_ < 0)
       TAMAAS_EXCEPTION("Hardening modulus should be positive");
     h = h_;
   }
   void setYieldStress(Real sigma_0_) {
     if (sigma_0_ < 0)
       TAMAAS_EXCEPTION("Yield stress should be positive");
     sigma_0 = sigma_0_;
   }
 
   const GridBase<Real>& getPlasticStrain() const { return *plastic_strain; }
   GridBase<Real>& getPlasticStrain() { return *plastic_strain; }
 
 protected:
   Model* model;
   Real sigma_0;  /// < initial yield stress
   Real h;        /// < hardening modulus
   std::shared_ptr<Grid<Real, 3>> plastic_strain, cumulated_plastic_strain;
 };
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <bool update>
 void IsotropicHardening<model_type::volume_2d>::computePlasticIncrement(
     Grid<Real, dim>& increment, const Grid<Real, dim>& strain,
     const Grid<Real, dim>& strain_increment) {
   influence::ElasticHelper<dim> elasticity(this->model->getShearModulus(),
                                            this->model->getPoissonRatio());
   using pmatrix = SymMatrixProxy<Real, dim>;
   using cpmatrix = SymMatrixProxy<const Real, dim>;
 
   Real sigma_0 = this->sigma_0, h = this->h;  // for captures
 
   Loop::loop(
       [elasticity, sigma_0,
        h] CUDA_LAMBDA(pmatrix dep,             // < plastic strain increment
                       cpmatrix epsilon,        // < total strain
                       cpmatrix delta_epsilon,  // < strain increment
                       pmatrix ep,              // < plastic strain
                       Real & p /* < cumulated plastic strain */) {
         // Trial elastic stress
         auto sigma_tr = elasticity(epsilon - ep + delta_epsilon);
 
         // Zero increment by default
         dep = 0;
 
         // Deviatoric trial stress
         decltype(sigma_tr) dev;
         dev.deviatoric(sigma_tr);
 
         // Von-Mises stress
         Real von_mises = std::sqrt(1.5) * dev.l2norm();
 
         // Plasticity condition
         if (von_mises - IsotropicHardening<model_type::volume_2d>::hardening(
                             p, h, sigma_0) >
             0) {
           // radial return
           Real dp =
               (von_mises - IsotropicHardening<model_type::volume_2d>::hardening(
                                p, h, sigma_0)) /
               (3 * elasticity.mu + h);
 
           dev *= 3 * dp / (2 * von_mises);  // saving memory (dev is delta ep)
           dep = dev;
 
           if (update) {  // constexpr if when C++17
             p += dp;
             ep += dep;
           }
         }
       },
       range<pmatrix>(increment), range<cpmatrix>(strain),
       range<cpmatrix>(strain_increment), range<pmatrix>(*this->plastic_strain),
       *this->cumulated_plastic_strain);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <bool update>
 void IsotropicHardening<model_type::volume_2d>::computeStress(
     Grid<Real, dim>& stress, const Grid<Real, dim>& strain,
     const Grid<Real, dim>& strain_increment) {
   using pmatrix = SymMatrixProxy<Real, dim>;
   using cpmatrix = SymMatrixProxy<const Real, dim>;
 
   const influence::ElasticHelper<dim> elasticity(
       this->model->getShearModulus(), this->model->getPoissonRatio());
 
   this->template computePlasticIncrement<update>(stress, strain,
                                                  strain_increment);
 
   Loop::loop(
       [elasticity] CUDA_LAMBDA(pmatrix sigma,           // < stress
                                cpmatrix epsilon,        // < total strain
                                cpmatrix delta_epsilon,  // < strain increment
                                cpmatrix ep              // < plastic strain
       ) {
         // !!! sigma contains delta_ep
         if (not update) {
           // dep is not contained in ep
           sigma *= -1;
           sigma += epsilon;
         } else {
           // dep is contained in ep, can discard value of sigma
           sigma = epsilon;
         }
         sigma -= ep;
         sigma += delta_epsilon;
         sigma = elasticity(sigma);
       },
       range<pmatrix>(stress), range<cpmatrix>(strain),
       range<cpmatrix>(strain_increment),
       range<cpmatrix>(*this->plastic_strain));
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // ISOTROPIC_HARDENING_HH
diff --git a/src/model/elasto_plastic/residual.cpp b/src/model/elasto_plastic/residual.cpp
index 79f80cd..9395ec2 100644
--- a/src/model/elasto_plastic/residual.cpp
+++ b/src/model/elasto_plastic/residual.cpp
@@ -1,159 +1,160 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "residual.hh"
 #include "grid_view.hh"
 #include "model_factory.hh"
 #include "model_type.hh"
 #include <list>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 ResidualTemplate<type>::ResidualTemplate(Model* model, Real sigma_0, Real h)
     : Residual(model), hardening(model, sigma_0, h) {
 
   // Registering operators for residual and displacement calculation
   ModelFactory::registerVolumeOperators(*model);
 
   // Initializing grids
   for (auto* grid : {&strain, &stress, &residual, &tmp}) {
     *grid = allocateGrid<type, false, Real>(model->getDiscretization(),
                                             trait::voigt);
   }
 
   // Registering fields
   model->registerField("stress", stress);
   model->registerField("strain", strain);
   model->registerField("residual", residual);
 
   plastic_filter = [this](UInt layer) {
 #if 0
     return true;
 #else
     return this->plastic_layers.find(layer) != this->plastic_layers.end();
 #endif
   };
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::computeResidual(GridBase<Real>& strain_increment) {
   Grid<Real, dim> inc(strain->sizes(), strain->getNbComponents(),
                       strain_increment.getInternalData());
   hardening.template computePlasticIncrement<false>(*residual, *strain, inc);
   this->updateFilter(*residual);
   this->model->applyElasticity(*residual, *residual);
   integralOperator("mindlin_gradient")
       .applyIf(*residual, *residual, plastic_filter);
   integralOperator("boussinesq_gradient")
       .apply(this->model->getTraction(), *tmp);
   *residual -= strain_increment;
   *residual += *tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::applyTangent(
     GridBase<Real>& output, GridBase<Real>& input,
     GridBase<Real>& current_strain_increment) {
   auto& inc = dynamic_cast<Grid<Real, dim>&>(current_strain_increment);
   auto& out = dynamic_cast<Grid<Real, dim>&>(output);
   auto& in = dynamic_cast<Grid<Real, dim>&>(input);
 
   hardening.applyTangentIncrement(out, in, *strain, inc);
   this->updateFilter(out);
   integralOperator("mindlin_gradient").applyIf(out, out, plastic_filter);
   out -= in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::computeStress(GridBase<Real>& strain_increment) {
   auto& inc = dynamic_cast<Grid<Real, dim>&>(strain_increment);
   hardening.template computeStress<false>(*stress, *strain, inc);
   // integralOperator("boussinesq_gradient")
   //     .apply(this->model->getTraction(), tmp);
   // this->model->applyElasticity(tmp, tmp);
   // stress += tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::updateState(
     GridBase<Real>& converged_strain_increment) {
   auto& inc = dynamic_cast<Grid<Real, dim>&>(converged_strain_increment);
   hardening.template computeStress<true>(*stress, *strain, inc);
   this->model->applyElasticity(*residual, hardening.getPlasticStrain());
   updateFilter(*residual);
   *strain += converged_strain_increment;
 
   // Computing displacements
   integralOperator("mindlin").applyIf(*residual, this->model->getDisplacement(),
                                       plastic_filter);
   Grid<Real, dim> disp_tmp(this->model->getDiscretization(), trait::components);
   integralOperator("boussinesq").apply(this->model->getTraction(), disp_tmp);
   this->model->getDisplacement() += disp_tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::computeResidualDisplacement(
     GridBase<Real>& strain_increment) {
   auto& inc = dynamic_cast<Grid<Real, dim>&>(strain_increment);
   hardening.template computePlasticIncrement<false>(*tmp, *strain, inc);
   updateFilter(*tmp);
   this->model->applyElasticity(*residual, *tmp);
 
   integralOperator("mindlin").applyIf(*residual, this->model->getDisplacement(),
                                       plastic_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::updateFilter(
     Grid<Real, dim>& plastic_strain_increment) {
   // plastic_layers.clear();
   for (UInt i : Loop::range(plastic_strain_increment.sizes().front())) {
     auto slice = make_view(plastic_strain_increment, i);
     if (slice.dot(slice) / slice.globalDataSize() > 1e-14)
       plastic_layers.insert(i);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ResidualTemplate<type>::setIntegrationMethod(integration_method method,
                                                   Real cutoff) {
   auto& mindlin = dynamic_cast<Mindlin<type, 1>&>(
       *this->model->getIntegralOperator("mindlin"));
   auto& mindlin_g = dynamic_cast<Mindlin<type, 2>&>(
       *this->model->getIntegralOperator("mindlin_gradient"));
 
   mindlin.setIntegrationMethod(method, cutoff);
   mindlin_g.setIntegrationMethod(method, cutoff);
 }
 
 /* -------------------------------------------------------------------------- */
 template class ResidualTemplate<model_type::volume_2d>;
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/model/elasto_plastic/residual.hh b/src/model/elasto_plastic/residual.hh
index c7e2f1a..ee16f27 100644
--- a/src/model/elasto_plastic/residual.hh
+++ b/src/model/elasto_plastic/residual.hh
@@ -1,155 +1,156 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef RESIDUAL_HH
 #define RESIDUAL_HH
 /* -------------------------------------------------------------------------- */
 #include "boussinesq.hh"
 #include "isotropic_hardening.hh"
 #include "mindlin.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 #include <unordered_set>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /**
  * @brief Residual manager
  */
 class Residual {
 
 public:
   /// Constructor
   Residual(Model* model) : model(model) {}
   /// Destructor
   virtual ~Residual() = default;
 
   // Pure virtual methods
 public:
   /// Compute the residual vector for a given strain increment
   virtual void computeResidual(GridBase<Real>& strain_increment) = 0;
   /// Apply tangent
   virtual void applyTangent(GridBase<Real>& output, GridBase<Real>& input,
                             GridBase<Real>& current_strain_increment) = 0;
   /// Compute the stresses for a given strain increment
   virtual void computeStress(GridBase<Real>& strain_increment) = 0;
   /// Update the plastic state
   virtual void updateState(GridBase<Real>& converged_strain_increment) = 0;
   /// Get residual vector
   virtual const GridBase<Real>& getVector() const = 0;
   /// Get plastic strain
   virtual const GridBase<Real>& getPlasticStrain() const = 0;
   /// Get stresses
   virtual const GridBase<Real>& getStress() const = 0;
   /// Compute displacement
   virtual void
   computeResidualDisplacement(GridBase<Real>& strain_increment) = 0;
   /// Set integration method (cutoff parameter ignored if linear integration)
   virtual void setIntegrationMethod(integration_method method,
                                     Real cutoff = 0) = 0;
 
   // Accessors
 public:
   Model& getModel() { return *model; }
   virtual Real getYieldStress() const = 0;
   virtual void setYieldStress(Real sigma_y) = 0;
   virtual Real getHardeningModulus() const = 0;
   virtual void setHardeningModulus(Real h) = 0;
 
 protected:
   Model* model;
 };
 
 /**
  * @brief Templated residual manager
  */
 template <model_type type>
 class ResidualTemplate : public Residual {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
 
 public:
   ResidualTemplate(Model* model, Real sigma_0, Real h);
 
   // Implementation
 public:
   /// Compute the residual vector for a given strain increment
   void computeResidual(GridBase<Real>& strain_increment) override;
   /// Apply tangent
   void applyTangent(GridBase<Real>& output, GridBase<Real>& input,
                     GridBase<Real>& current_strain_increment) override;
   /// Compute the stresses for a given strain increment
   void computeStress(GridBase<Real>& strain_increment) override;
   /// Update the plastic state
   void updateState(GridBase<Real>& converged_strain_increment) override;
   /// Compute displacement
   void computeResidualDisplacement(GridBase<Real>& strain_increment) override;
   /// Set integration method (cutoff parameter ignored if linear integration)
   void setIntegrationMethod(integration_method method,
                             Real cutoff = 0) override;
 
   // Accessors
 public:
   /// Get residual vector
   const GridBase<Real>& getVector() const override { return *residual; }
   /// Get plastic strain
   const GridBase<Real>& getPlasticStrain() const override {
     return hardening.getPlasticStrain();
   }
   /// Get stresses
   const GridBase<Real>& getStress() const override { return *stress; }
 
   Real getYieldStress() const override { return hardening.getYieldStress(); }
 
   void setYieldStress(Real sigma_y) override {
     hardening.setYieldStress(sigma_y);
   }
 
   Real getHardeningModulus() const override {
     return hardening.getHardeningModulus();
   }
 
   void setHardeningModulus(Real h) override {
     hardening.setHardeningModulus(h);
   }
 
 private:
   /// Convenience function
   const IntegralOperator& integralOperator(const std::string& name) const {
     return *this->model->getIntegralOperator(name);
   }
 
   /// Add non-zero layers of plastic strain into the filter
   void updateFilter(Grid<Real, dim>& plastic_strain_increment);
 
 protected:
   IsotropicHardening<type> hardening;
   std::shared_ptr<Grid<Real, 3>> strain, stress, residual, tmp;
 
   std::unordered_set<UInt> plastic_layers;
   std::function<bool(UInt)> plastic_filter;
 };
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 
 #endif  // RESIDUAL_HH
diff --git a/src/model/functional.hh b/src/model/functional.hh
index 91e7e6d..4390768 100644
--- a/src/model/functional.hh
+++ b/src/model/functional.hh
@@ -1,51 +1,52 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FUNCTIONAL_HH
 #define FUNCTIONAL_HH
 /* -------------------------------------------------------------------------- */
 #include "be_engine.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace functional {
 
 /// Generic functional class for the cost function of the optimization problem
 class Functional {
 public:
   /// Destructor
   virtual ~Functional() = default;
 
 public:
   /// Compute functional
   virtual Real computeF(GridBase<Real>& variable,
                         GridBase<Real>& dual) const = 0;
   /// Compute functional gradient
   virtual void computeGradF(GridBase<Real>& variable,
                             GridBase<Real>& gradient) const = 0;
 };
 
 }  // namespace functional
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // _FUNCTIONAL_HH
diff --git a/src/model/hooke.cpp b/src/model/hooke.cpp
index bb81a63..3fcb61b 100644
--- a/src/model/hooke.cpp
+++ b/src/model/hooke.cpp
@@ -1,74 +1,75 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "hooke.hh"
 #include "influence.hh"
 #include "loop.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 template <model_type type>
 void Hooke<type>::apply(GridBase<Real>& strain, GridBase<Real>& stress) const {
   constexpr auto dim = model_type_traits<type>::dimension;
   const influence::ElasticHelper<dim> elasticity(
       this->model->getShearModulus(), this->model->getPoissonRatio());
 
   // Checking incompressibility
   if (elasticity.nu == 0.5)
     TAMAAS_EXCEPTION("Incompressibility error");
 
   // Checking number of components
   if (strain.getNbComponents() == dim * dim) {
     Loop::loop(
         [elasticity] CUDA_LAMBDA(MatrixProxy<Real, dim, dim> sigma,
                                  MatrixProxy<const Real, dim, dim> epsilon) {
           sigma = elasticity(epsilon);
         },
         range<MatrixProxy<Real, dim, dim>>(stress),
         range<MatrixProxy<const Real, dim, dim>>(strain));
   }
 
   // in case we have voigt notation
   else if (strain.getNbComponents() == voigt_size<dim>::value) {
     Loop::loop(
         [elasticity] CUDA_LAMBDA(SymMatrixProxy<Real, dim> sigma,
                                  SymMatrixProxy<const Real, dim> epsilon) {
           sigma = elasticity(epsilon);
         },
         range<SymMatrixProxy<Real, dim>>(stress),
         range<SymMatrixProxy<const Real, dim>>(strain));
   }
 
   else
     TAMAAS_EXCEPTION("Strain components do not match dimension");
 }
 
 /* -------------------------------------------------------------------------- */
 template class Hooke<model_type::basic_1d>;
 template class Hooke<model_type::basic_2d>;
 template class Hooke<model_type::surface_1d>;
 template class Hooke<model_type::surface_2d>;
 template class Hooke<model_type::volume_1d>;
 template class Hooke<model_type::volume_2d>;
 
 }  // namespace tamaas
diff --git a/src/model/hooke.hh b/src/model/hooke.hh
index da90e0f..34a2516 100644
--- a/src/model/hooke.hh
+++ b/src/model/hooke.hh
@@ -1,56 +1,57 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef HOOKE_HH
 #define HOOKE_HH
 /* -------------------------------------------------------------------------- */
 #include "integral_operator.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Applies Hooke's law of elasticity
  */
 template <model_type type>
 class Hooke : public IntegralOperator {
 public:
   using IntegralOperator::IntegralOperator;
 
   /// Type of underlying model
   model_type getType() const override { return type; }
 
   /// Hooke's law computes stresses ~ Neumann
   IntegralOperator::kind getKind() const override {
     return IntegralOperator::dirac;
   }
 
   /// Does not update
   void updateFromModel() override {}
 
   /// Apply Hooke's tensor
   void apply(GridBase<Real>& strain, GridBase<Real>& stress) const override;
 };
 
 }  // namespace tamaas
 
 #endif  // HOOKE_HH
diff --git a/src/model/influence.hh b/src/model/influence.hh
index bd95c31..7c8e31a 100644
--- a/src/model/influence.hh
+++ b/src/model/influence.hh
@@ -1,328 +1,329 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef INFLUENCE_HH
 #define INFLUENCE_HH
 /* -------------------------------------------------------------------------- */
 #include "loop.hh"
 #include "static_types.hh"
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 namespace influence {
 
 namespace {
 const Complex I(0, 1);  /// < imaginary unit
 constexpr inline Real sign(bool upper) { return (upper) ? 1. : -1.; }
 }  // namespace
 
 template <bool conjugate, UInt dim_q>  // dim + 1 to help dim template deduction
 inline Vector<Complex, dim_q + 1>
     __device__ __host__ computeD(const VectorProxy<const Real, dim_q>& q) {
   constexpr Real s = -sign(conjugate);
   const auto q_norm = q.l2norm();
   return {{{Complex{0, s * q(0) / q_norm}, Complex{0, s * q(1) / q_norm},
             Complex{1, 0}}}};
 }
 
 template <UInt dim_q>  // dim + 1 to help dim template deduction
 __device__ __host__ inline Vector<Complex, dim_q + 1>
 computeD2(const VectorProxy<const Real, dim_q>& q) {
   const auto q_norm = (q.l2norm() < 1e-16) ? 1 : q.l2norm();
   return {
       {{Complex{0, q(0) / q_norm}, Complex{0, q(1) / q_norm}, Complex{0, 0}}}};
 }
 
 /* -------------------------------------------------------------------------- */
 /// Functor to apply Hooke's tensor
 template <UInt dim>
 struct ElasticHelper {
   ElasticHelper(Real mu, Real nu)
       : mu(mu), nu(nu), lambda(2 * mu * nu / (1 - 2 * nu)) {}
 
   template <typename DT, typename ST>
   __device__ __host__ Matrix<std::remove_cv_t<DT>, dim, dim>
   operator()(const StaticMatrix<DT, ST, dim, dim>& gradu) const {
     auto trace = gradu.trace();
     Matrix<std::remove_cv_t<DT>, dim, dim> sigma;
     for (UInt i = 0; i < dim; ++i)
       for (UInt j = 0; j < dim; ++j)
         sigma(i, j) =
             (i == j) * lambda * trace + mu * (gradu(i, j) + gradu(j, i));
     return sigma;
   }
 
   template <typename DT, typename ST>
   __device__ __host__ SymMatrix<std::remove_cv_t<DT>, dim>
   operator()(const StaticSymMatrix<DT, ST, dim>& eps) const {
     SymMatrix<std::remove_cv_t<DT>, dim> sigma;
     auto trace = eps.trace();
     for (UInt i = 0; i < dim; ++i)
       sigma(i) = lambda * trace + 2 * mu * eps(i);
     for (UInt i = dim; i < voigt_size<dim>::value; ++i)
       sigma(i) = 2 * mu * eps(i);
     return sigma;
   }
 
   template <typename DT, typename ST>
   __device__ __host__ Matrix<std::remove_cv_t<DT>, dim, dim>
   inverse(const StaticMatrix<DT, ST, dim, dim>& sigma) const {
     Matrix<std::remove_cv_t<DT>, dim, dim> epsilon;
     auto trace = sigma.trace();
     auto c1 = 1. / (2 * mu);
     auto c2 = -lambda / (3 * lambda + 2 * mu);
 
     for (UInt i = 0; i < dim; ++i)
       for (UInt j = 0; j < dim; ++j)
         epsilon(i, j) = c1 * (sigma(i, j) + c2 * trace * (i == j));
   }
 
   const Real mu, nu, lambda;
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Class for the Kelvin tensor
 template <UInt dim, UInt derivative_order>
 class Kelvin;
 
 /**
  * @brief Kelvin base tensor
  * See arXiv:1811.11558 for details.
  */
 template <>
 class Kelvin<3, 0> {
 protected:
   static constexpr UInt dim = 3;
   static constexpr UInt order = 0;
 
 public:
   Kelvin(Real mu, Real nu) : mu(mu), b(4 * (1 - nu)) {}
 
   template <bool upper, bool apply_q_power = false, typename ST>
   __device__ __host__ inline Vector<Complex, dim>
   applyU0(const VectorProxy<const Real, dim - 1>& q,
           const StaticVector<Complex, ST, dim>& f) const {
     // upper is ignored here
     auto d2 = computeD2(q);
     auto q_power = (apply_q_power) ? 1. / q.l2norm() : 1.;
     d2 *= d2.dot(f);
     d2 += b * f;
     d2(2) -= f(2);
     d2 *= q_power / (2. * mu * b);
     return d2;
   }
 
   template <bool upper, bool apply_q_power = false, typename ST>
   __device__ __host__ inline Vector<Complex, dim>
   applyU1(const VectorProxy<const Real, dim - 1>& q,
           const StaticVector<Complex, ST, dim>& f) const {
     auto d = computeD<upper>(q);
     auto q_power = (apply_q_power) ? 1. / q.l2norm() : 1.;
     d *= d.dot(f);
     d *= q_power * sign(upper) / (2. * mu * b);
     return d;
   }
 
 protected:
   const Real mu, b;
 };
 
 /* -------------------------------------------------------------------------- */
 /// Kelvin first derivative
 template <>
 class Kelvin<3, 1> : protected Kelvin<3, 0> {
   using parent = Kelvin<3, 0>;
 
 protected:
   static constexpr UInt dim = parent::dim;
   static constexpr UInt order = parent::order + 1;
 
 public:
   using parent::parent;
   template <bool upper, bool apply_q_power = false, typename ST>
   __device__ __host__ inline Vector<Complex, dim>
   applyU0(const VectorProxy<const Real, dim - 1>& q,
           const StaticMatrix<Complex, ST, dim, dim>& f) const {
     // apply_q_power is ignored here
     auto tmp = f * computeD<upper>(q);
     auto res = Kelvin<3, 0>::applyU0<false>(q, tmp);
     res *= -sign(upper);
     Vector<Real, dim> e3{{{0, 0, 1}}};
     tmp.template mul<false>(f, e3);
     res += Kelvin<3, 0>::applyU1<upper>(q, tmp);
     return res;
   }
 
   template <bool upper, bool apply_q_power = false, typename ST>
   inline Vector<Complex, dim> __device__ __host__
   applyU1(const VectorProxy<const Real, dim - 1>& q,
           const StaticMatrix<Complex, ST, dim, dim>& f) const {
     // apply_q_power is ignored here
     auto tmp = f * computeD<upper>(q);
     auto res = Kelvin<3, 0>::applyU1<upper>(q, tmp);
     res *= -sign(upper);
     return res;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /// Kelvin second derivative
 template <>
 class Kelvin<3, 2> : protected Kelvin<3, 1> {
   using parent = Kelvin<3, 1>;
   static constexpr UInt dim = parent::dim;
   static constexpr UInt order = parent::order + 1;
 
 public:
   using parent::parent;
   template <bool upper, bool apply_q_power = false, typename ST>
   __device__ __host__ inline Matrix<Complex, dim, dim>
   applyU0(const VectorProxy<const Real, dim - 1>& q,
           const StaticMatrix<Complex, ST, dim, dim>& f) const {
     auto tmp = Kelvin<3, 1>::applyU0<upper>(q, f);
     auto q_power = (apply_q_power) ? q.l2norm() : 1.;
     tmp *= -sign(upper);
     auto res = outer(computeD<upper>(q), tmp);
     Vector<Real, dim> e3{{{0, 0, 1}}};
     res += outer(e3, Kelvin<3, 1>::applyU1<upper>(q, f));
     res *= -1. * q_power;  // << -1 for grad_x
     return res;
   }
 
   template <bool upper, bool apply_q_power = false, typename ST>
   __device__ __host__ inline Matrix<Complex, dim, dim>
   applyU1(const VectorProxy<const Real, dim - 1>& q,
           const StaticMatrix<Complex, ST, dim, dim>& f) const {
     auto tmp = Kelvin<3, 1>::applyU1<upper>(q, f);
     auto q_power = (apply_q_power) ? q.l2norm() : 1.;
     auto res = outer(computeD<upper>(q), tmp);
     res *= -1. * -sign(upper) * q_power;  // << -1 for grad_x
     return res;
   }
 
   template <typename ST>
   __device__ __host__ inline Matrix<Complex, dim, dim>
   applyDiscontinuityTerm(const StaticMatrix<Complex, ST, dim, dim>& f) const {
 
     Vector<Real, dim> e3{{{0, 0, 1}}};
     auto res = (f * e3);
     res *= -this->b;
     res(2) += 2. * f(2, 2);
     e3(2) *= -1 / (this->mu * this->b);  // << -1 for grad_x
     return outer(e3, res);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /// Class for the Boussinesq tensor
 template <UInt dim, UInt derivative_order>
 class Boussinesq;
 
 template <>
 class Boussinesq<3, 0> {
 protected:
   static constexpr UInt dim = 3;
   static constexpr UInt order = 0;
 
 public:
   /// Constructor
   Boussinesq(Real mu, Real nu)
       : mu(mu), nu(nu), lambda(2 * mu * nu / (1 - 2 * nu)) {}
 
   template <bool apply_q_power = false, typename ST>
   __device__ __host__ inline Vector<Complex, dim>
   applyU0(const StaticVector<Complex, ST, dim>& t,
           const VectorProxy<const Real, dim - 1>& q) const {
     // This guy has the property Bt(q) = B(-q). Since we know we recieve -q as
     // an argument, we can just apply B without transpose
     auto dplus = computeD<true>(q), dminus = computeD<false>(q),
          d2 = computeD2(q);
     auto q_power = (apply_q_power) ? 1. / q.l2norm() : 1.;
     auto res = 2. * t;
     res += ((1. - 2. * nu) * dminus.dot(t)) * dplus;
     res += d2.dot(t) * d2;
     res(2) -= t(2);
     res *= q_power / (2. * mu);
     return res;
   }
 
   template <bool apply_q_power = false, typename ST>
   __device__ __host__ inline Vector<Complex, dim>
   applyU1(const StaticVector<Complex, ST, dim>& t,
           const VectorProxy<const Real, dim - 1>& q) const {
     // This guy does not have the property that Bt(q) = B(-q), so we have to
     // apply Bt(q) for real. This makes us correct (in the line below) for the
     // fact that we recieve -q as an argument.
     auto dplus = computeD<false>(q);
     auto q_power = (apply_q_power) ? 1. / q.l2norm() : 1.;
     auto res = q_power * (dplus.dot(t) / (2. * mu)) * dplus;
     return res;
   }
 
 protected:
   const Real mu, nu, lambda;
 };
 
 /* -------------------------------------------------------------------------- */
 /// Boussinesq first gradient
 template <>
 class Boussinesq<3, 1> : protected Boussinesq<3, 0> {
 protected:
   using parent = Boussinesq<3, 0>;
   static constexpr UInt dim = parent::dim;
   static constexpr UInt order = parent::order + 1;
 
 public:
   using parent::parent;
   template <bool apply_q_power = false, typename ST>
   __device__ __host__ inline Matrix<Complex, dim, dim>
   applyU0(const StaticVector<Complex, ST, dim>& t,
           const VectorProxy<const Real, dim - 1>& q) const {
     // taking into account K(-q) convolution
     auto dbar = computeD<false>(q);
     Vector<Real, dim> e3{{{0, 0, 1}}};
     auto res = outer(dbar, Boussinesq<3, 0>::applyU0(t, q));
     res *= -1.;
     res += outer(e3, Boussinesq<3, 0>::applyU1(t, q));
     return res;
   }
 
   template <bool apply_q_power = false, typename ST>
   __device__ __host__ inline Matrix<Complex, dim, dim>
   applyU1(const StaticVector<Complex, ST, dim>& t,
           const VectorProxy<const Real, dim - 1>& q) const {
     // taking into account K(-q) convolution
     auto dbar = computeD<false>(q);
     auto res = outer(dbar, Boussinesq<3, 0>::applyU1(t, q));
     res *= -1;
     return res;
   }
 };
 
 }  // namespace influence
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 
 #endif  // INFLUENCE_HH
diff --git a/src/model/integral_operator.cpp b/src/model/integral_operator.cpp
index 5b7cf00..a7a1e9c 100644
--- a/src/model/integral_operator.cpp
+++ b/src/model/integral_operator.cpp
@@ -1,41 +1,42 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "integral_operator.hh"
 #include <ostream>
 #include <map>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace {
 const std::map<IntegralOperator::kind, std::string> repr{
     {IntegralOperator::neumann, "neumann"},
     {IntegralOperator::dirichlet, "dirichlet"}};
 }
 
 std::ostream& operator<<(std::ostream& o, const IntegralOperator::kind& val) {
   o << repr.at(val);
   return o;
 }
 
 #undef INTEGRAL_KINDS
 
 }  // namespace tamaas
diff --git a/src/model/integral_operator.hh b/src/model/integral_operator.hh
index 597472a..4cde60e 100644
--- a/src/model/integral_operator.hh
+++ b/src/model/integral_operator.hh
@@ -1,95 +1,96 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef INTEGRAL_OPERATOR_HH
 #define INTEGRAL_OPERATOR_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_base.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 class Model;
 
 /**
  * @brief Generic class for integral operators
  */
 class IntegralOperator {
 public:
   /// Kind of operator
   enum kind { neumann, dirichlet, dirac };
 
 public:
   /// Constructor
   IntegralOperator(Model* model) : model(model) {}
   /// Virtual destructor for subclasses
   virtual ~IntegralOperator() = default;
 
   /// Apply operator on input
   virtual void apply(GridBase<Real>& input, GridBase<Real>& output) const = 0;
 
   /// Apply operator on filtered input
   virtual void applyIf(GridBase<Real>& input, GridBase<Real>& output,
                        const std::function<bool(UInt)>& /*unused*/) const {
     apply(input, output);
   }
 
   /// Update any data dependent on model parameters
   virtual void updateFromModel() = 0;
 
   /// Get model
   const Model& getModel() const { return *model; }
 
   /// Kind
   virtual kind getKind() const = 0;
 
   /// Type
   virtual model_type getType() const = 0;
 
   /// Norm
   virtual Real getOperatorNorm() {
     TAMAAS_EXCEPTION("operator does not implement norm");
   }
 
   /// Dense shape (for Scipy integration)
   virtual std::pair<UInt, UInt> matvecShape() const {
     TAMAAS_EXCEPTION("operator does not implement "
                      "scipy.sparse.linalg.LinearOperator interface");
   }
 
   /// matvec definition
   virtual GridBase<Real> matvec(GridBase<Real>& /*x*/) const {
     TAMAAS_EXCEPTION("operator does not implement "
                      "scipy.sparse.linalg.LinearOperator interface");
   }
 
 protected:
   Model* model = nullptr;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Printing IntegralOperator::kind to string */
 /* -------------------------------------------------------------------------- */
 std::ostream& operator<<(std::ostream& o, const IntegralOperator::kind& val);
 }  // namespace tamaas
 
 #endif  // INTEGRAL_OPERATOR_HH
diff --git a/src/model/integration/accumulator.hh b/src/model/integration/accumulator.hh
index b817e92..bbadcc4 100644
--- a/src/model/integration/accumulator.hh
+++ b/src/model/integration/accumulator.hh
@@ -1,228 +1,229 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ACCUMULATOR_HH
 #define ACCUMULATOR_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_hermitian.hh"
 #include "integrator.hh"
 #include "model_type.hh"
 #include "static_types.hh"
 #include <array>
 #include <thrust/iterator/zip_iterator.h>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /// Accumulation integral manager
 template <model_type type, typename Source,
           typename = std::enable_if_t<is_proxy<Source>::value>>
 class Accumulator {
   using trait = model_type_traits<type>;
   using BufferType = GridHermitian<Real, trait::boundary_dimension>;
 
 public:
   /// Constructor
   Accumulator() {
     // Resizing accumulators (with source)
     for (auto&& acc : accumulator)
       acc.setNbComponents(Source::size);
   }
 
   /// Initialize uniform mesh
   void makeUniformMesh(UInt N, Real domain_size) {
     Real dx = domain_size / (N - 1);
     Real x = 0;
 
     node_positions.resize(N);
     for (UInt i = 0; i < N; ++i, x += dx) {
       node_positions[i] = x;
     }
   }
 
   const std::vector<Real>& nodePositions() const { return node_positions; }
 
   /// Direction flag
   enum class direction { forward, backward };
 
   /// Forward/Backward iterator for integration passes
   template <direction dir>
   struct iterator {
     using integ = Integrator<1>;
     /// Constructor
     iterator(Accumulator& acc, Int k) : acc(acc), k(k) {
       l = (dir != direction::forward) ? k + 1 : k;
     }
     /// Copy constructor
     iterator(const iterator& o)
         : acc(o.acc), k(o.k), l(o.l), r(o.r), xc(o.xc) {}
 
     static constexpr bool upper = dir == direction::backward;
     /// Compare
     bool operator!=(const iterator& o) const { return k != o.k; }
     /// Increment
     iterator& operator++() {
       // update current layer and element. skip last operation
       if (not setup()) {
         next();
         return *this;
       }
 
       auto r = this->r, xc = this->xc;  // for capture by value
       Loop::loop(
           [r, xc] CUDA_LAMBDA(VectorProxy<const Real, trait::dimension - 1> qv,
                               Source wk0, Source wk1, Source acc_g0,
                               Source acc_g1) {
             Real q = qv.l2norm();
             acc_g0 += wk0 * integ::template G0<upper, 0>(q, r, xc);
             acc_g0 += wk1 * integ::template G0<upper, 1>(q, r, xc);
             acc_g1 += wk0 * integ::template G1<upper, 0>(q, r, xc);
             acc_g1 += wk1 * integ::template G1<upper, 1>(q, r, xc);
           },
           range<VectorProxy<const Real, trait::dimension - 1>>(
               acc.waveVectors())
               .headless(),
           range<Source>(acc.nodeValues()[k]).headless(),
           range<Source>(acc.nodeValues()[k + 1]).headless(),
           range<Source>(acc.accumulator.front()).headless(),
           range<Source>(acc.accumulator.back()).headless());
 
       if (mpi::rank() == 0) {
         // accumulating the fundamental mode
         Source wk0(&this->acc.nodeValues()[this->k](0)),
             wk1(&this->acc.nodeValues()[this->k + 1](0));
 
         Source acc_tensor(&acc.accumulator.front()(0));
         acc_tensor += wk0 * integ::template F<0>(this->r);
         acc_tensor += wk1 * integ::template F<1>(this->r);
       }
 
       next();
       return *this;
     }
     /// Dereference iterator (TODO uniformize tuple types)
     std::tuple<Int, Real, BufferType&, BufferType&> operator*() {
       return {l, acc.node_positions[l], acc.accumulator.front(),
               acc.accumulator.back()};
     }
 
   protected:
     /// Update index layer and element info
     bool setup() {
       if (k + 1 >= static_cast<Int>(acc.node_positions.size()) or k < 0)
         return false;
 
       r = 0.5 * (acc.node_positions[k + 1] - acc.node_positions[k]);
       xc = 0.5 * (acc.node_positions[k + 1] + acc.node_positions[k]);
       return true;
     }
 
     /// Set current layer and update element index
     void next() {
       l = layer(k);
       k = nextElement(k);
     }
 
     /// Element index => layer index
     static Int layer(Int element) {
       return element + (dir == direction::forward);
     }
 
     /// Next element index in right direction
     static Int nextElement(Int element) {
       return element + ((dir == direction::forward) ? 1 : -1);
     }
 
   protected:
     Accumulator& acc;  /// accumulator holder
     Int k = 0;         ///< element index
     Int l = 0;         ///< layer index
     Real r = 0;        ///< element radius
     Real xc = 0;       ///< element center
   };
 
   /// Range for convenience
   template <typename Iterator>
   struct acc_range {
     Iterator _begin, _end;
     Iterator begin() const { return _begin; }
     Iterator end() const { return _end; }
   };
 
   /// Prepare forward loop
   acc_range<iterator<direction::forward>>
   forward(std::vector<BufferType>& nvalues,
           const Grid<Real, trait::boundary_dimension>& wvectors) {
     using it = iterator<direction::forward>;
     reset(nvalues, wvectors);
     return acc_range<it>{it(*this, 0), it(*this, node_positions.size())};
   }
 
   /// Prepare backward loop
   acc_range<iterator<direction::backward>>
   backward(std::vector<BufferType>& nvalues,
            const Grid<Real, trait::boundary_dimension>& wvectors) {
     using it = iterator<direction::backward>;
     reset(nvalues, wvectors);
     // don't ask why the range has those values
     // if it works, don't change it
     return acc_range<it>{it(*this, node_positions.size() - 2), it(*this, -2)};
   }
 
   void reset(std::vector<BufferType>& nvalues,
              const Grid<Real, trait::boundary_dimension>& wvectors) {
     node_values = &nvalues;
     wavevectors = &wvectors;
 
     for (auto&& acc : accumulator) {
       acc.resize(wvectors.sizes());
       acc = 0;
     }
   }
 
   std::vector<BufferType>& nodeValues() {
     TAMAAS_ASSERT(node_values, "Node values is invalid");
     return *node_values;
   }
 
   const Grid<Real, trait::boundary_dimension>& waveVectors() {
     TAMAAS_ASSERT(wavevectors, "Wavevectors is invalid");
     return *wavevectors;
   }
 
   /// Create a range over the elements in the mesh
   auto elements() {
     auto range = Loop::range(node_positions.size() - 1);
     auto begin = thrust::make_zip_iterator(thrust::make_tuple(
         range.begin(), node_positions.begin(), node_positions.begin() + 1));
     auto end = thrust::make_zip_iterator(thrust::make_tuple(
         range.end(), node_positions.end() - 1, node_positions.end()));
     return acc_range<decltype(begin)>{begin, end};
   }
 
 private:
   std::array<BufferType, 2> accumulator;
   std::vector<Real> node_positions;
   std::vector<BufferType>* node_values;
   const Grid<Real, trait::boundary_dimension>* wavevectors;
 };
 }  // namespace tamaas
 #endif  // ACCUMULATOR_HH
diff --git a/src/model/integration/element.cpp b/src/model/integration/element.cpp
index 351d766..8bddcc9 100644
--- a/src/model/integration/element.cpp
+++ b/src/model/integration/element.cpp
@@ -1,24 +1,25 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {}  // namespace tamaas
diff --git a/src/model/integration/element.hh b/src/model/integration/element.hh
index 4588443..0c8ed84 100644
--- a/src/model/integration/element.hh
+++ b/src/model/integration/element.hh
@@ -1,65 +1,66 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef ELEMENT_HH
 #define ELEMENT_HH
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <boost/preprocessor/array/elem.hpp>
 #include <expolit/expolit>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 template <UInt interpolation_order>
 struct ExponentialElement;
 
 template <>
 struct ExponentialElement<1> {
 
   template <UInt shape>
   static constexpr __device__ __host__ expolit::Polynomial<Real, 1> shapes() {
     constexpr expolit::Polynomial<Real, 1> z({0, 1});
 
     if (shape == 0)
       return 0.5 + (-0.5) * z;
     return 0.5 + 0.5 * z;
   }
 
   static constexpr __device__ __host__ auto sign(bool upper) {
     return (upper) ? -1 : 1;
   }
 
   template <bool upper, UInt shape>
   static constexpr __device__ __host__ auto g0(Real q) {
     constexpr expolit::Polynomial<Real, 1> z({0, 1});
     return expolit::exp((q * sign(upper)) * z) * shapes<shape>();
   }
 
   template <bool upper, UInt shape>
   static constexpr __device__ __host__ auto g1(Real q) {
     constexpr expolit::Polynomial<Real, 1> z({0, 1});
     return expolit::exp((q * sign(upper)) * z) * (q * z * shapes<shape>());
   }
 
 };  // namespace tamaas
 }  // namespace tamaas
 
 #endif  // ELEMENT_HH
diff --git a/src/model/integration/integrator.hh b/src/model/integration/integrator.hh
index 1b268c9..053e40b 100644
--- a/src/model/integration/integrator.hh
+++ b/src/model/integration/integrator.hh
@@ -1,77 +1,78 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef INTEGRATOR_HH
 #define INTEGRATOR_HH
 /* -------------------------------------------------------------------------- */
 #include "element.hh"
 #include <expolit/expolit>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 #define BOUNDS                                                                 \
   thrust::pair<Real, Real> { -1, 1 }
 
 template <UInt interpolation_order>
 class Integrator {
   using element = ExponentialElement<interpolation_order>;
   static constexpr std::pair<Real, Real> bounds{-1, 1};
 
 public:
   /// Standard integral of \f$\exp(\pm qy) \phi(y)\f$ over an element of radius
   /// \f$r\f$ and center \f$x_c\f$
   template <bool upper, UInt shape>
   __device__ __host__ static Real G0(Real q, Real r, Real xc) {
     const auto F = element::template g0<upper, shape>(q * r);
     return r * std::exp(element::sign(upper) * q * xc) *
            expolit::definite_integral(BOUNDS, F);
   }
 
   /// Standard integral of \f$qy\exp(\pm qy) \phi(y)\f$ over an element of
   /// radius \f$r\f$ and center \f$x_c\f$
   template <bool upper, UInt shape>
   __device__ __host__ static Real G1(Real q, Real r, Real xc) {
     const auto c = q * r;
     const auto integrals =
         std::make_pair(element::template g0<upper, shape>(c),
                        element::template g1<upper, shape>(c));
     return r * std::exp(element::sign(upper) * q * xc) *
            (q * xc * expolit::definite_integral(BOUNDS, integrals.first) +
             expolit::definite_integral(BOUNDS, integrals.second));
   }
 
   /// Standard integral of \f$\phi(y)\f$ over an element of radius
   /// \f$r\f$ and center \f$x_c\f$. Used for fundamental mode
   template <UInt shape>
   __device__ __host__ constexpr static Real F(Real r) {
     return r * expolit::definite_integral(BOUNDS,
                                           element::template shapes<shape>());
   }
 };
 
 // static member declare
 template <UInt interpolation_order>
 constexpr std::pair<Real, Real> Integrator<interpolation_order>::bounds;
 }  // namespace tamaas
 
 #undef BOUNDS
 
 #endif  // INTEGRATOR_HH
diff --git a/src/model/kelvin.cpp b/src/model/kelvin.cpp
index 94f6a45..90a6098 100644
--- a/src/model/kelvin.cpp
+++ b/src/model/kelvin.cpp
@@ -1,139 +1,140 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "kelvin.hh"
 #include "logger.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /* Constructors */
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 Kelvin<type, derivative>::Kelvin(Model* model) : VolumePotential<type>(model) {
   setIntegrationMethod(integration_method::linear, 1e-12);
 }
 
 template <model_type type, UInt derivative>
 void Kelvin<type, derivative>::setIntegrationMethod(integration_method method,
                                                     Real cutoff) {
   this->method = method;
   this->cutoff = cutoff;
 
   Logger logger;
 
   if (this->method == integration_method::linear) {
     logger.get(LogLevel::debug)
         << TAMAAS_DEBUG_MSG("Setting linear integration method");
     this->initialize(dtrait::template source_components<type>,
                      dtrait::template out_components<type>,
                      this->model->getDiscretization()[0]);
   }
 
   else {
     logger.get(LogLevel::debug) << TAMAAS_DEBUG_MSG(
         "Setting cutoff integration method (cutoff " << this->cutoff << ')');
     this->initialize(dtrait::template source_components<type>,
                      dtrait::template out_components<type>, 1);
   }
 
   auto max_q = Loop::reduce<operation::max>(
       [] CUDA_LAMBDA(VectorProxy<const Real, trait::boundary_dimension> qv) {
         return qv.l2norm();
       },
       range<VectorProxy<const Real, trait::boundary_dimension>>(
           this->wavevectors));
 
   if (this->method == integration_method::linear and
       not std::isfinite(std::exp(max_q * this->model->getSystemSize()[0])))
     logger.get(LogLevel::warning)
         << "Probable overflow of integral computation (consider "
            "changing integration method to integration_method::cutoff or "
            "compiling with real_type='long double')\n";
 }
 
 /* -------------------------------------------------------------------------- */
 /* Operator implementation */
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 void Kelvin<type, derivative>::applyIf(GridBase<Real>& source,
                                        GridBase<Real>& out,
                                        filter_t pred) const {
   KelvinInfluence kelvin(this->model->getShearModulus(),
                          this->model->getPoissonRatio());
 
   parent::transformSource(source, pred);
 
   // Reset buffer values
   for (auto&& layer : this->out_buffer)
     layer = 0;
 
   if (method == integration_method::linear) {
     linearIntegral(out, kelvin);
   } else {
     cutoffIntegral(out, kelvin);
   }
 }
 
 template <model_type type, UInt derivative>
 void Kelvin<type, derivative>::linearIntegral(GridBase<Real>& out,
                                               KelvinInfluence& kelvin) const {
   detail::KelvinHelper<type, KelvinInfluence> helper;
 
   helper.applyIntegral(this->source_buffer, this->out_buffer, this->wavevectors,
                        this->model->getSystemSize().front(), kelvin);
   helper.applyFreeTerm(this->source_buffer, this->out_buffer, kelvin);
   helper.makeFundamentalGreatAgain(this->out_buffer);
 
   parent::transformOutput(
       [](auto&& out_buffer, auto layer) ->
       typename parent::BufferType& { return out_buffer[layer]; },
       out);
 }
 
 template <model_type type, UInt derivative>
 void Kelvin<type, derivative>::cutoffIntegral(GridBase<Real>& out,
                                               KelvinInfluence& kelvin) const {
   detail::KelvinHelper<type, KelvinInfluence> helper;
 
   auto func = [&](auto&& out_buffer, auto layer) ->
       typename parent::BufferType& {
     auto&& out = out_buffer.front();
     out = 0;
     helper.applyIntegral(this->source_buffer, out, layer, this->wavevectors,
                          this->model->getSystemSize().front(), cutoff, kelvin);
     helper.applyFreeTerm(this->source_buffer[layer], out, kelvin);
     helper.makeFundamentalGreatAgain(out);
     return out;
   };
   parent::transformOutput(func, out);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation */
 /* -------------------------------------------------------------------------- */
 template class Kelvin<model_type::volume_2d, 0>;
 template class Kelvin<model_type::volume_2d, 1>;
 template class Kelvin<model_type::volume_2d, 2>;
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/model/kelvin.hh b/src/model/kelvin.hh
index ed1ce61..b460f90 100644
--- a/src/model/kelvin.hh
+++ b/src/model/kelvin.hh
@@ -1,77 +1,78 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef KELVIN_HH
 #define KELVIN_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_hermitian.hh"
 #include "influence.hh"
 #include "integration/accumulator.hh"
 #include "kelvin_helper.hh"
 #include "model_type.hh"
 #include "volume_potential.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /// Integration method enumeration
 enum class integration_method { cutoff, linear };
 
 /**
  * @brief Kelvin tensor
  */
 template <model_type type, UInt derivative>
 class Kelvin : public VolumePotential<type> {
   static_assert(type == model_type::volume_1d || type == model_type::volume_2d,
                 "Only volume types are supported");
   using trait = model_type_traits<type>;
   using dtrait = derivative_traits<derivative>;
   using parent = VolumePotential<type>;
 
 protected:
   using KelvinInfluence = influence::Kelvin<trait::dimension, derivative>;
   using ktrait = detail::KelvinTrait<KelvinInfluence>;
   using Source = typename ktrait::source_t;
   using Out = typename ktrait::out_t;
   using filter_t = typename parent::filter_t;
 
 public:
   /// Constructor
   Kelvin(Model* model);
 
   /// Apply the Kelvin-tensor_order operator
   void applyIf(GridBase<Real>& source, GridBase<Real>& out,
                filter_t pred) const override;
 
   /// Set the integration method for volume operator
   void setIntegrationMethod(integration_method method, Real cutoff);
 
 private:
   void linearIntegral(GridBase<Real>& out, KelvinInfluence& kelvin) const;
   void cutoffIntegral(GridBase<Real>& out, KelvinInfluence& kelvin) const;
 
 protected:
   integration_method method = integration_method::linear;
   Real cutoff;
 };
 
 }  // namespace tamaas
 
 #endif  // KELVIN_HH
diff --git a/src/model/kelvin_helper.hh b/src/model/kelvin_helper.hh
index fa12419..6060253 100644
--- a/src/model/kelvin_helper.hh
+++ b/src/model/kelvin_helper.hh
@@ -1,348 +1,349 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef KELVIN_HELPER_HH
 #define KELVIN_HELPER_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include "influence.hh"
 #include "integration/accumulator.hh"
 #include "logger.hh"
 #include "model.hh"
 #include "model_type.hh"
 #include <tuple>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 namespace detail {
 
 /* -------------------------------------------------------------------------- */
 /// Trait for kelvin local types
 template <typename T>
 struct KelvinTrait;
 
 template <UInt dim>
 struct KelvinTrait<influence::Kelvin<dim, 0>> {
   using source_t = VectorProxy<Complex, dim>;
   using out_t = VectorProxy<Complex, dim>;
 };
 
 template <UInt dim>
 struct KelvinTrait<influence::Kelvin<dim, 1>> {
   using source_t = SymMatrixProxy<Complex, dim>;
   using out_t = VectorProxy<Complex, dim>;
 };
 
 template <UInt dim>
 struct KelvinTrait<influence::Kelvin<dim, 2>> {
   using source_t = SymMatrixProxy<Complex, dim>;
   using out_t = SymMatrixProxy<Complex, dim>;
 };
 
 template <UInt dim>
 struct KelvinTrait<influence::Boussinesq<dim, 0>> {
   using source_t = VectorProxy<Complex, dim>;
   using out_t = VectorProxy<Complex, dim>;
 };
 
 template <UInt dim>
 struct KelvinTrait<influence::Boussinesq<dim, 1>> {
   using source_t = VectorProxy<Complex, dim>;
   using out_t = SymMatrixProxy<Complex, dim>;
 };
 
 /* -------------------------------------------------------------------------- */
 
 /// Helper to apply integral representation on output
 template <model_type type, typename kelvin_t,
           typename = typename KelvinTrait<kelvin_t>::source_t>
 struct KelvinHelper {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
   static constexpr UInt bdim = trait::boundary_dimension;
 
   using BufferType = GridHermitian<Real, bdim>;
   using source_t = typename KelvinTrait<kelvin_t>::source_t;
   using out_t = typename KelvinTrait<kelvin_t>::out_t;
 
   virtual ~KelvinHelper() = default;
 
   /**
    @brief Apply the regular part of Kelvin to source and sum into output
 
    This function performs the linear integration algorithm using the
    accumulator.
   */
   void applyIntegral(std::vector<BufferType>& source,
                      std::vector<BufferType>& out,
                      const Grid<Real, bdim>& wavevectors, Real domain_size,
                      const kelvin_t& kelvin) {
     // Sanity check
     if (source.size() != out.size())
       TAMAAS_EXCEPTION(
           "Linear integration requires source and out of same sizes");
 
     accumulator.makeUniformMesh(source.size(), domain_size);
 
     auto waverange = range<VectorProxy<const Real, bdim>>(wavevectors);
 
     for (auto&& tuple : accumulator.forward(source, wavevectors)) {
       auto&& l = std::get<0>(tuple);
       auto&& xl = std::get<1>(tuple);
       auto&& acc_g0 = std::get<2>(tuple);
       auto&& acc_g1 = std::get<3>(tuple);
       Loop::loop(
           [xl, kelvin] CUDA_LAMBDA(VectorProxy<const Real, bdim> qv, out_t u,
                                    source_t acc_g0, source_t acc_g1) {
             Real q = qv.l2norm();
             auto dense_G0 = dense(acc_g0), dense_G1 = dense(acc_g1);
             auto tmp = kelvin.template applyU1<false, true>(qv, dense_G0);
             tmp *= -q * xl;
             tmp += kelvin.template applyU0<false, true>(qv, dense_G0);
             tmp += kelvin.template applyU1<false, true>(qv, dense_G1);
             tmp *= std::exp(-q * xl);
             u += tmp;
           },
           waverange.headless(), range<out_t>(out[l]).headless(),
           range<source_t>(acc_g0).headless(),
           range<source_t>(acc_g1).headless());
     }
 
     for (auto&& tuple : accumulator.backward(source, wavevectors)) {
       auto&& l = std::get<0>(tuple);
       auto&& xl = std::get<1>(tuple);
       auto&& acc_g0 = std::get<2>(tuple);
       auto&& acc_g1 = std::get<3>(tuple);
       Loop::loop(
           [xl, kelvin] CUDA_LAMBDA(VectorProxy<const Real, bdim> qv, out_t u,
                                    source_t acc_g0, source_t acc_g1) {
             Real q = qv.l2norm();
             auto dense_G0 = dense(acc_g0), dense_G1 = dense(acc_g1);
             auto tmp = kelvin.template applyU1<true, true>(qv, dense_G0);
             tmp *= -q * xl;
             tmp += kelvin.template applyU0<true, true>(qv, dense_G0);
             tmp += kelvin.template applyU1<true, true>(qv, dense_G1);
             tmp *= std::exp(q * xl);
             u += tmp;  // should automatically symmetrize if needed
           },
           waverange.headless(), range<out_t>(out[l]).headless(),
           range<source_t>(acc_g0).headless(),
           range<source_t>(acc_g1).headless());
     }
   }
 
   template <bool upper>
   struct cutoff_functor {
     Real r, xc, dx, cutoff;
     kelvin_t kelvin;
 
     CUDA_LAMBDA void operator()(VectorProxy<const Real, bdim> qv, source_t wj0,
                                 source_t wj1, out_t out_i) const {
       using integ = Integrator<1>;
 
       Real q = qv.l2norm();
 
       // Do not compute if element is too far from source
       if (std::exp(-q * std::abs(dx)) < std::abs(cutoff))
         return;
 
       auto dense_wj0 = dense(wj0);
       auto dense_wj1 = dense(wj1);
       Real G[4] = {integ::template G0<upper, 0>(q, r, dx),
                    integ::template G1<upper, 0>(q, r, dx),
                    integ::template G0<upper, 1>(q, r, dx),
                    integ::template G1<upper, 1>(q, r, dx)};
 
       // Do first shape function
       out_i += G[0] * kelvin.template applyU0<upper, true>(qv, dense_wj0);
       out_i += G[1] * kelvin.template applyU1<upper, true>(qv, dense_wj0);
 
       // Do second shape function
       out_i += G[2] * kelvin.template applyU0<upper, true>(qv, dense_wj1);
       out_i += G[3] * kelvin.template applyU1<upper, true>(qv, dense_wj1);
     }
   };
 
 public:
   /**
 
   @brief Apply the regular part of Kelvin to source and sum into output
 
    This function performs the cutoff integration algorithm. Not to be
    confused with its overload above.
   */
   void applyIntegral(std::vector<BufferType>& source, BufferType& out,
                      UInt layer, const Grid<Real, bdim>& wavevectors,
                      Real domain_size, Real cutoff, const kelvin_t& kelvin) {
     accumulator.makeUniformMesh(source.size(), domain_size);
 
     auto xi = accumulator.nodePositions()[layer];
     auto waverange = range<VectorProxy<const Real, bdim>>(wavevectors);
 
     for (auto bounds : accumulator.elements()) {
       const auto j = thrust::get<0>(bounds);
       const auto xj0 = thrust::get<1>(bounds);
       const auto xj1 = thrust::get<2>(bounds);
 
       const auto r = 0.5 * std::abs(xj0 - xj1);
       const auto xc = 0.5 * (xj0 + xj1);
       const auto dx = xc - xi;
 
       Logger().get(LogLevel::debug)
           << TAMAAS_DEBUG_MSG("Integration element " << j);
 
       // Treat lower case
       if (j < layer) {
         const cutoff_functor<false> func{r, xc, dx, cutoff, kelvin};
         Loop::loop(func, waverange.headless(),
                    range<source_t>(source[j]).headless(),
                    range<source_t>(source[j + 1]).headless(),
                    range<out_t>(out).headless());
       }
 
       // Treat upper case
       else {
         const cutoff_functor<true> func{r, xc, dx, cutoff, kelvin};
         Loop::loop(func, waverange.headless(),
                    range<source_t>(source[j]).headless(),
                    range<source_t>(source[j + 1]).headless(),
                    range<out_t>(out).headless());
       }
     }
   }
 
   /// Apply free term of distribution derivative
   void applyFreeTerm(std::vector<BufferType>& source,
                      std::vector<BufferType>& out, const kelvin_t& kelvin) {
     for (UInt l : Loop::range(source.size())) {
       applyFreeTerm(source[l], out[l], kelvin);
     }
   }
 
   /// Apply free term of distribution derivative (layer)
   void applyFreeTerm(BufferType& /*source*/, BufferType& /*out*/,
                      const kelvin_t& /*kelvin*/) {}
 
   /// Making the output free of communist NaN
   void makeFundamentalGreatAgain(std::vector<BufferType>& out) {
     for (auto&& layer : out)
       makeFundamentalGreatAgain(layer);
   }
 
   /// Making the output free of communist NaN (layer)
   void makeFundamentalGreatAgain(BufferType& /*out_layer*/) {}
 
 protected:
   Accumulator<type, source_t> accumulator;
 };
 
 /// Applying free term for double gradient of Kelvin
 template <>
 inline void
 KelvinHelper<model_type::volume_2d, influence::Kelvin<3, 2>>::applyFreeTerm(
     BufferType& source, BufferType& out,
     const influence::Kelvin<3, 2>& kelvin) {
   // No need for headless loops as discontinuity term does not depend on q
   Loop::loop(
       [kelvin] CUDA_LAMBDA(out_t u, source_t w) {
         u += kelvin.applyDiscontinuityTerm(dense(w));
       },
       range<out_t>(out), range<source_t>(source));
 }
 
 /// \cond DO_NOT_DOCUMENT
 // Setting fundamental mode to zero: we've got no other choice here
 template <>
 inline void KelvinHelper<model_type::volume_2d, influence::Kelvin<3, 0>>::
     makeFundamentalGreatAgain(BufferType& layer) {
   // Fundamental model lives only in root rank
   if (mpi::rank() != 0)
     return;
 
   out_t u(&layer(0));
   u = 0;
 }
 /// \endcond
 
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 struct SurfaceTractionHelper {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
   static constexpr UInt bdim = trait::boundary_dimension;
 
   using BufferType = GridHermitian<Real, bdim>;
   using kelvin_t = influence::Kelvin<3, 2>;
   using source_t = typename KelvinTrait<kelvin_t>::source_t;
   using out_t = typename KelvinTrait<kelvin_t>::out_t;
 
   /// Compute surface tractions due to eigenstress distribution
   template <bool apply_q_power>
   void computeSurfaceTractions(std::vector<BufferType>& source,
                                BufferType& tractions,
                                const Grid<Real, bdim>& wavevectors,
                                Real domain_size, const kelvin_t& kelvin,
                                const influence::ElasticHelper<dim>& el) {
     accumulator.makeUniformMesh(source.size(), domain_size);
 
     // only doing backward loop because forward loop gives 0 for l = 0
     for (auto&& tuple : accumulator.backward(source, wavevectors)) {
       auto&& l = std::get<0>(tuple);
       auto&& acc_g0 = std::get<2>(tuple);
       auto&& acc_g1 = std::get<3>(tuple);
       // Just skip all layers and let the accumulator accumulate
       if (l != 0)
         continue;
 
       Loop::loop(
           [kelvin, el] CUDA_LAMBDA(VectorProxy<const Real, bdim> qv,
                                    VectorProxy<Complex, dim> t, source_t acc_g0,
                                    source_t acc_g1) {
             // computing strains
             auto dense_G0 = dense(acc_g0), dense_G1 = dense(acc_g1);
             auto strains =
                 kelvin.template applyU0<true, apply_q_power>(qv, dense_G0);
             strains +=
                 kelvin.template applyU1<true, apply_q_power>(qv, dense_G1);
 
             // computing traction vector
             Vector<Real, dim> normal{{{0, 0, -1}}};
             t = el(strains) * normal;
           },
           range<VectorProxy<const Real, bdim>>(wavevectors).headless(),
           range<VectorProxy<Complex, dim>>(tractions).headless(),
           range<source_t>(acc_g0).headless(),
           range<source_t>(acc_g1).headless());
     }
   }
 
 protected:
   Accumulator<type, source_t> accumulator;
 };
 
 }  // namespace detail
 
 }  // namespace tamaas
 
 #endif  // KELVIN_HELPER_HH
diff --git a/src/model/meta_functional.cpp b/src/model/meta_functional.cpp
index 592f448..5290f2d 100644
--- a/src/model/meta_functional.cpp
+++ b/src/model/meta_functional.cpp
@@ -1,54 +1,55 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "meta_functional.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 namespace functional {
 
 Real MetaFunctional::computeF(GridBase<Real>& variable,
                               GridBase<Real>& dual) const {
   Real F = 0;
   for (const auto& f : functionals)
     F += f->computeF(variable, dual);
   return F;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void MetaFunctional::computeGradF(GridBase<Real>& variable,
                                   GridBase<Real>& gradient) const {
   gradient = 0;
   for (const auto& f : functionals)
     f->computeGradF(variable, gradient);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void MetaFunctional::addFunctionalTerm(std::shared_ptr<Functional> functional) {
   functionals.push_back(std::move(functional));
 }
 
 }  // namespace functional
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/model/meta_functional.hh b/src/model/meta_functional.hh
index 71838db..fd6eeb6 100644
--- a/src/model/meta_functional.hh
+++ b/src/model/meta_functional.hh
@@ -1,58 +1,59 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef META_FUNCTIONAL_HH
 #define META_FUNCTIONAL_HH
 
 #include "functional.hh"
 #include "tamaas.hh"
 #include <list>
 #include <memory>
 
 namespace tamaas {
 
 namespace functional {
 
 /// Meta functional that contains list of functionals
 class MetaFunctional : public Functional {
   using FunctionalList = std::list<std::shared_ptr<Functional>>;
 
 public:
   /// Compute functional
   Real computeF(GridBase<Real>& variable, GridBase<Real>& dual) const override;
   /// Compute functional gradient
   void computeGradF(GridBase<Real>& variable,
                     GridBase<Real>& gradient) const override;
 
   /// Add functional to the list
   void addFunctionalTerm(std::shared_ptr<Functional> functional);
 
 protected:
   FunctionalList functionals;
 };
 
 }  // namespace functional
 
 }  // namespace tamaas
 
 #endif  // META_FUNCTIONAL_HH
diff --git a/src/model/mindlin.cpp b/src/model/mindlin.cpp
index c625491..2f66b40 100644
--- a/src/model/mindlin.cpp
+++ b/src/model/mindlin.cpp
@@ -1,161 +1,162 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mindlin.hh"
 #include "boussinesq_helper.hh"
 #include "influence.hh"
 #include "kelvin_helper.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 Mindlin<type, derivative>::Mindlin(Model* model) : parent(model) {
   surface_tractions.setNbComponents(trait::components);
   surface_tractions.resize(this->source_buffer.front().sizes());
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type, UInt derivative>
 void Mindlin<type, derivative>::applyIf(GridBase<Real>& source,
                                         GridBase<Real>& out,
                                         filter_t pred) const {
   Real nu = this->model->getPoissonRatio(), mu = this->model->getShearModulus();
   influence::Kelvin<trait::dimension, 2> kelvin_strain(mu, nu);
   influence::ElasticHelper<trait::dimension> elasticity(mu, nu);
   detail::SurfaceTractionHelper<type> thelper;
 
   const Real L = this->model->getSystemSize().front();
 
   parent::transformSource(source, pred);
 
   // Reset buffer values
   for (auto&& layer : this->out_buffer)
     layer = 0;
 
   // computing surface tractions (q power cancelled with
   // boussinesq)
   surface_tractions = 0;
   thelper.template computeSurfaceTractions<true>(
       this->source_buffer, surface_tractions, this->wavevectors, L,
       kelvin_strain, elasticity);
   surface_tractions *= -1;
 
   if (this->method == integration_method::linear)
     linearIntegral(out);
   else
     cutoffIntegral(out);
 }
 
 template <model_type type, UInt derivative>
 void Mindlin<type, derivative>::linearIntegral(GridBase<Real>& out) const {
   Real nu = this->model->getPoissonRatio(), mu = this->model->getShearModulus();
   Real L = this->model->getSystemSize().front();
 
   influence::Kelvin<trait::dimension, derivative> kelvin(mu, nu);
   influence::Boussinesq<trait::dimension, derivative - 1> boussinesq(mu, nu);
   influence::ElasticHelper<trait::dimension> elasticity(mu, nu);
 
   detail::KelvinHelper<type, decltype(kelvin)> helper;
   detail::SurfaceTractionHelper<type> thelper;
   detail::BoussinesqHelper<type, decltype(boussinesq)> bhelper;
 
   // apply kelvin
   helper.applyIntegral(this->source_buffer, this->out_buffer, this->wavevectors,
                        L, kelvin);
   helper.applyFreeTerm(this->source_buffer, this->out_buffer, kelvin);
   // no need for fundamental correction
 
   // apply boussinesq (q power cancelled with mindlin 2-grad)
   bhelper.template apply<true>(surface_tractions, this->out_buffer,
                                this->wavevectors, L, boussinesq);
 
   // Correcting for fundamental mode
   Vector<Real, trait::dimension> n{{{0, 0, -1}}};
 
   for (UInt i : Loop::range(this->source_buffer.size())) {
     typename detail::KelvinTrait<decltype(kelvin)>::source_t w(
         this->source_buffer[i](0));
     typename detail::KelvinTrait<decltype(kelvin)>::out_t u(
         this->out_buffer[i](0));
 
     auto t = dense(w) * n;
     bhelper.makeFundamentalModeGreatAgain(t, u, elasticity);
   }
 
   parent::transformOutput(
       [](auto&& out_buffer, auto layer) ->
       typename parent::BufferType& { return out_buffer[layer]; },
       out);
 }
 
 template <model_type type, UInt derivative>
 void Mindlin<type, derivative>::cutoffIntegral(GridBase<Real>& out) const {
   Real nu = this->model->getPoissonRatio(), mu = this->model->getShearModulus();
   Real L = this->model->getSystemSize().front();
 
   influence::Kelvin<trait::dimension, derivative> kelvin(mu, nu);
   influence::Boussinesq<trait::dimension, derivative - 1> boussinesq(mu, nu);
   influence::ElasticHelper<trait::dimension> elasticity(mu, nu);
 
   detail::KelvinHelper<type, decltype(kelvin)> helper;
   detail::SurfaceTractionHelper<type> thelper;
   detail::BoussinesqHelper<type, decltype(boussinesq)> bhelper;
 
   Vector<Real, trait::dimension> n{{{0, 0, -1}}};
 
   auto func = [&](auto&& out_buffer, auto layer) ->
       typename parent::BufferType& {
     auto&& out = out_buffer.front();
 
     // Reset previous values
     out = 0;
 
     // Apply kelvin
     helper.applyIntegral(this->source_buffer, out, layer, this->wavevectors, L,
                          this->cutoff, kelvin);
     helper.applyFreeTerm(this->source_buffer[layer], out, kelvin);
     helper.makeFundamentalGreatAgain(out);
 
     // Apply boussinesq to cancel surface tractions
     bhelper.template apply<true>(surface_tractions, out, layer,
                                  this->wavevectors, this->source_buffer.size(),
                                  L, boussinesq);
 
     // Take care of fundamental mode
     typename detail::KelvinTrait<decltype(kelvin)>::source_t w(
         this->source_buffer[layer](0));
     typename detail::KelvinTrait<decltype(kelvin)>::out_t u(out(0));
 
     auto t = dense(w) * n;
     bhelper.makeFundamentalModeGreatAgain(t, u, elasticity);
 
     return out;
   };
   parent::transformOutput(func, out);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation                                                     */
 /* -------------------------------------------------------------------------- */
 template class Mindlin<model_type::volume_2d, 1>;
 template class Mindlin<model_type::volume_2d, 2>;
 }  // namespace tamaas
diff --git a/src/model/mindlin.hh b/src/model/mindlin.hh
index 7f47be6..fa8ed0d 100644
--- a/src/model/mindlin.hh
+++ b/src/model/mindlin.hh
@@ -1,60 +1,61 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MINDLIN_HH
 #define MINDLIN_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_hermitian.hh"
 #include "kelvin.hh"
 #include "model_type.hh"
 #include "volume_potential.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /**
  * @brief Mindlin tensor
  */
 template <model_type type, UInt derivative>
 class Mindlin : public Kelvin<type, derivative> {
   static_assert(type == model_type::volume_1d || type == model_type::volume_2d,
                 "Only volume types are supported");
   using trait = model_type_traits<type>;
   using parent = Kelvin<type, derivative>;
   using filter_t = typename parent::filter_t;
 
 public:
   /// Constructor
   Mindlin(Model* model);
   /// Apply the Mindlin-tensor_order operator
   void applyIf(GridBase<Real>& source, GridBase<Real>& out,
                filter_t pred) const override;
 
 protected:
   void linearIntegral(GridBase<Real>& out) const;
   void cutoffIntegral(GridBase<Real>& out) const;
 
 protected:
   mutable GridHermitian<Real, trait::boundary_dimension> surface_tractions;
 };
 
 }  // namespace tamaas
 
 #endif  // MINDLIN_HH
diff --git a/src/model/model.cpp b/src/model/model.cpp
index da722bd..4bc85a9 100644
--- a/src/model/model.cpp
+++ b/src/model/model.cpp
@@ -1,192 +1,193 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 #include "be_engine.hh"
 #include "logger.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 void Model::setElasticity(Real E_, Real nu_) {
   setYoungModulus(E_);
   setPoissonRatio(nu_);
   updateOperators();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::applyElasticity(GridBase<Real>& stress,
                             const GridBase<Real>& strain) const {
   operators.at("hooke")->apply(const_cast<GridBase<Real>&>(strain), stress);
 }
 
 /* -------------------------------------------------------------------------- */
 GridBase<Real>& Model::getTraction() { return getField("traction"); }
 const GridBase<Real>& Model::getTraction() const { return (*this)["traction"]; }
 
 /* -------------------------------------------------------------------------- */
 GridBase<Real>& Model::getDisplacement() { return getField("displacement"); }
 const GridBase<Real>& Model::getDisplacement() const {
   return (*this)["displacement"];
 }
 
 /* -------------------------------------------------------------------------- */
 const std::vector<Real>& Model::getSystemSize() const { return system_size; }
 
 /* -------------------------------------------------------------------------- */
 const std::vector<UInt>& Model::getDiscretization() const {
   return discretization;
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::solveNeumann() {
   engine->registerNeumann();
   engine->solveNeumann(getTraction(), getDisplacement());
 }
 
 void Model::solveDirichlet() {
   engine->registerDirichlet();
   engine->solveDirichlet(getDisplacement(), getTraction());
 }
 
 /* -------------------------------------------------------------------------- */
 IntegralOperator* Model::getIntegralOperator(const std::string& name) const {
   return operators.at(name).get();
 }
 
 /* -------------------------------------------------------------------------- */
 std::vector<std::string> Model::getIntegralOperators() const {
   std::vector<std::string> keys;
   keys.reserve(operators.size());
 
   std::transform(operators.begin(), operators.end(), std::back_inserter(keys),
                  [](auto&& pair) { return pair.first; });
   return keys;
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::updateOperators() {
   for (auto& op : operators)
     op.second->updateFromModel();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumper(std::shared_ptr<ModelDumper> dumper) {
   this->dumpers.push_back(std::move(dumper));
 }
 
 void Model::dump() const {
   for (const auto& dumper : dumpers)
     if (dumper)
       dumper->dump(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::registerField(const std::string& name,
                           std::shared_ptr<GridBase<Real>> field) {
   fields[name] = std::move(field);
 }
 
 const GridBase<Real>& Model::getField(const std::string& name) const try {
   return *fields.at(name);
 } catch (std::out_of_range& e) {
   Logger().get(LogLevel::warning)
       << "Field " << name << " not registered in model\n";
   throw e;
 }
 
 GridBase<Real>& Model::getField(const std::string& name) try {
   return *fields.at(name);
 } catch (std::out_of_range& e) {
   Logger().get(LogLevel::warning)
       << "Field " << name << " not registered in model\n";
   throw e;
 }
 
 std::vector<std::string> Model::getFields() const {
   std::vector<std::string> keys;
   keys.reserve(fields.size());
 
   std::transform(fields.begin(), fields.end(), std::back_inserter(keys),
                  [](auto&& pair) { return pair.first; });
   return keys;
 }
 
 const GridBase<Real>& Model::operator[](const std::string& name) const {
   return getField(name);
 }
 
 GridBase<Real>& Model::operator[](const std::string& name) {
   return getField(name);
 }
 
 std::vector<std::string> Model::getBoundaryFields() const {
   std::vector<std::string> boundary_fields;
   const auto& fields = this->getFields();
   std::copy_if(
       fields.begin(), fields.end(), std::back_inserter(boundary_fields),
       [&](const auto& name) { return this->isBoundaryField((*this)[name]); });
   return boundary_fields;
 }
 
 /* -------------------------------------------------------------------------- */
 std::ostream& operator<<(std::ostream& o, const Model& _this) {
   o << "Model<" << _this.getType() << "> (E = " << _this.getYoungModulus()
     << ", nu = " << _this.getPoissonRatio() << ")\n";
 
   auto out_collec = [&o](auto&& collec) {
     std::for_each(collec.begin(), collec.end() - 1,
                   [&o](const auto& x) { o << x << ", "; });
     o << collec.back();
   };
 
   // Printing domain size
   o << "  - domain = [";
   out_collec(_this.getSystemSize());
   o << "]\n";
 
   // Printing discretization
   o << "  - discretization = [";
   out_collec(_this.getDiscretization());
   o << "]\n";
 
   if (mpi::size() > 1) {
     o << "  - global discretization = [";
     out_collec(_this.getGlobalDiscretization());
     o << "]\n";
   }
 
   // Print fields
   o << "  - registered fields = [";
   out_collec(_this.getFields());
   o << "]\n";
 
   o << "  - registered operators = [";
   out_collec(_this.getIntegralOperators());
   o << "]";
 
   if (not _this.dumpers.empty())
     o << "\n  - " << _this.dumpers.size() << " registered dumpers";
 
   return o;
 }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/model/model.hh b/src/model/model.hh
index 8cc2711..eebde52 100644
--- a/src/model/model.hh
+++ b/src/model/model.hh
@@ -1,213 +1,214 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MODEL_HH
 #define MODEL_HH
 /* -------------------------------------------------------------------------- */
 #include "be_engine.hh"
 #include "grid_base.hh"
 #include "integral_operator.hh"
 #include "model_dumper.hh"
 #include "model_type.hh"
 #include "tamaas.hh"
 #include <algorithm>
 #include <memory>
 #include <unordered_map>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * @brief Model containing pressure and displacement
  * This class is a container for the model fields. It is supposed to be
  * dimension agnostic, hence the GridBase members.
  */
 class Model {
 protected:
   /// Constructor
   Model(std::vector<Real> system_size, std::vector<UInt> discretization)
       : system_size(std::move(system_size)),
         discretization(std::move(discretization)) {}
 
 public:
   /// Destructor
   virtual ~Model() = default;
 
 public:
   /// Set elasticity parameters
   void setElasticity(Real E, Real nu);
   /// Get Hertz contact modulus
   Real getHertzModulus() const { return E / (1 - nu * nu); }
   /// Get Young's modulus
   Real getYoungModulus() const { return E; }
   /// Get Poisson's ratio
   Real getPoissonRatio() const { return nu; }
   /// Get shear modulus
   Real getShearModulus() const { return E / (2 * (1 + nu)); }
   /// Set Young's modulus
   void setYoungModulus(Real E_) {
     if (E_ < 0)
       TAMAAS_EXCEPTION("Elastic modulus should be positive");
     this->E = E_;
     updateOperators();
   }
 
   /// Set Poisson's ratio
   void setPoissonRatio(Real nu_) {
     if (nu_ > 0.5 or nu_ <= -1)
       TAMAAS_EXCEPTION("Poisson ratio should be in ]-1, 0.5]");
     this->nu = nu_;
     updateOperators();
   }
 
   // Model info accessors
 public:
   /// Get model type
   virtual model_type getType() const = 0;
   /// Get system physical size
   const std::vector<Real>& getSystemSize() const;
   /// Get boundary system physical size
   virtual std::vector<Real> getBoundarySystemSize() const = 0;
   /// Get discretization
   const std::vector<UInt>& getDiscretization() const;
   /// Get discretization of global MPI system
   virtual std::vector<UInt> getGlobalDiscretization() const = 0;
   /// Get boundary discretization
   virtual std::vector<UInt> getBoundaryDiscretization() const = 0;
   /// Get boundary element engine
   BEEngine& getBEEngine() {
     TAMAAS_ASSERT(engine, "BEEngine was not initialized");
     return *engine;
   }
 
   // Exposing some common operators
 public:
   /// Apply Hooke's law
   void applyElasticity(GridBase<Real>& stress,
                        const GridBase<Real>& strain) const;
 
   /// Solve Neumann problem using default neumann operator
   void solveNeumann();
   /// Solve Dirichlet problem using default dirichlet operator
   void solveDirichlet();
 
 public:
   /// Register a new integral operator
   template <typename Operator>
   IntegralOperator* registerIntegralOperator(const std::string& name);
   /// Get a registerd integral operator
   IntegralOperator* getIntegralOperator(const std::string& name) const;
   /// Get list of integral operators
   std::vector<std::string> getIntegralOperators() const;
   /// Get operators mapcar
   const auto& getIntegralOperatorsMap() const { return operators; }
   /// Tell operators to update their cache
   void updateOperators();
 
 public:
   /// Get pressure
   GridBase<Real>& getTraction();
   /// Get pressure
   const GridBase<Real>& getTraction() const;
   /// Get displacement
   GridBase<Real>& getDisplacement();
   /// Get displacement
   const GridBase<Real>& getDisplacement() const;
   /// Register a field
   void registerField(const std::string& name,
                      std::shared_ptr<GridBase<Real>> field);
   /// Get a field
   const GridBase<Real>& getField(const std::string& name) const;
   /// Get a non-const field
   GridBase<Real>& getField(const std::string& name);
   /// Get fields
   std::vector<std::string> getFields() const;
   /// Get fields map
   const auto& getFieldsMap() const { return fields; }
   /// Get a field
   const GridBase<Real>& operator[](const std::string& name) const;
   /// Get a non-const field
   GridBase<Real>& operator[](const std::string& name);
   /// Determine if a field is defined on boundary
   virtual bool isBoundaryField(const GridBase<Real>& field) const = 0;
   /// Return list of fields defined on boundary
   std::vector<std::string> getBoundaryFields() const;
 
 public:
   /// Set the dumper object
   void addDumper(std::shared_ptr<ModelDumper> dumper);
   /// Dump the model
   void dump() const;
 
   friend std::ostream& operator<<(std::ostream& o, const Model& _this);
 
 protected:
   Real E = 1, nu = 0;
 
   std::vector<Real> system_size;
   std::vector<UInt> discretization;
   std::unique_ptr<BEEngine> engine = nullptr;
   std::unordered_map<std::string, std::shared_ptr<IntegralOperator>> operators;
   std::unordered_map<std::string, std::shared_ptr<GridBase<Real>>> fields;
   std::vector<std::shared_ptr<ModelDumper>> dumpers;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Template functions */
 /* -------------------------------------------------------------------------- */
 template <typename Operator>
 IntegralOperator* Model::registerIntegralOperator(const std::string& name) {
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("registering operator " + name);
   operators[name] = std::make_unique<Operator>(this);
   return operators[name].get();
 }
 
 /* -------------------------------------------------------------------------- */
 /* Output model to stream */
 /* -------------------------------------------------------------------------- */
 std::ostream& operator<<(std::ostream& o, const Model& _this);
 
 /* -------------------------------------------------------------------------- */
 /* Simpler grid allocation */
 /* -------------------------------------------------------------------------- */
 template <bool boundary, typename T>
 std::unique_ptr<GridBase<T>> allocateGrid(Model& model) {
   return allocateGrid<boundary, T>(
       model.getType(), (boundary) ? model.getBoundaryDiscretization()
                                   : model.getDiscretization());
 }
 
 template <bool boundary, typename T>
 std::unique_ptr<GridBase<T>> allocateGrid(Model& model, UInt nc) {
   return allocateGrid<boundary, T>(model.getType(),
                                    (boundary)
                                        ? model.getBoundaryDiscretization()
                                        : model.getDiscretization(),
                                    nc);
 }
 
 }  // namespace tamaas
 
 #endif  // MODEL_HH
diff --git a/src/model/model_dumper.hh b/src/model/model_dumper.hh
index d7428c1..742378f 100644
--- a/src/model/model_dumper.hh
+++ b/src/model/model_dumper.hh
@@ -1,44 +1,45 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MODEL_DUMPER_HH
 #define MODEL_DUMPER_HH
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 class Model; // forward declaration
 
 class ModelDumper {
 public:
   virtual ~ModelDumper() = default;
 
 public:
   virtual void dump(const Model& model) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 inline ModelDumper& operator<<(ModelDumper& dumper, Model& model) {
   dumper.dump(model);
   return dumper;
 }
 
 }  // namespace tamaas
 #endif // MODEL_DUMPER_HH
diff --git a/src/model/model_factory.cpp b/src/model/model_factory.cpp
index 9f6e9c2..51b06d6 100644
--- a/src/model/model_factory.cpp
+++ b/src/model/model_factory.cpp
@@ -1,125 +1,126 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "model_factory.hh"
 #include "model_template.hh"
 #include <boost/preprocessor/seq.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// \cond HIDDEN_SYMBOLS
 #define MODEL_TYPE_CASE_MACRO(truc, arguments, type)                           \
   case type: {                                                                 \
     result = std::make_unique<Concrete<type>>(std::forward<Args>(args)...);    \
     break;                                                                     \
   }
 /// \endcond
 
 #define IMPLEMENTED_MODEL_TYPES TAMAAS_MODEL_TYPES
 
 template <typename Abstract, template <model_type> class Concrete,
           class... Args>
 decltype(auto) createFromModelType(model_type type, Args&&... args) {
   std::unique_ptr<Abstract> result = nullptr;
 
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(MODEL_TYPE_CASE_MACRO, ~, IMPLEMENTED_MODEL_TYPES);
   default:
     TAMAAS_EXCEPTION("Model type not implemented");
   }
 
   return result;
 }
 
 #undef MODEL_TYPE_CASE_MACRO
 #undef IMPLEMENTED_MODEL_TYPES
 
 std::unique_ptr<Model>
 ModelFactory::createModel(model_type type, const std::vector<Real>& system_size,
                           const std::vector<UInt>& discretization) {
   return createFromModelType<Model, ModelTemplate>(type, system_size,
                                                    discretization);
 }
 
 std::unique_ptr<Model> ModelFactory::createModel(const Model& model) {
   auto copy = createModel(model.getType(), model.getSystemSize(),
                           model.getDiscretization());
 
   copy->setElasticity(model.getYoungModulus(), model.getPoissonRatio());
 
 #define FIELD_COPY_CASE(truc, arguments, dim)                                  \
   case dim: {                                                                  \
     const auto* ptr = dynamic_cast<const Grid<Real, dim>*>(&f);                \
     if (ptr != nullptr) {                                                      \
       auto new_f = std::make_shared<Grid<Real, dim>>(ptr->sizes(),             \
                                                      ptr->getNbComponents());  \
       *new_f = *ptr;                                                           \
       copy->registerField(k, std::move(new_f));                                \
     }                                                                          \
     break;                                                                     \
   }
 
   // Register and copy all fields
   for (auto&& k : model.getFields()) {
     auto&& f = model[k];
 
     switch (f.getDimension()) {
       BOOST_PP_SEQ_FOR_EACH(FIELD_COPY_CASE, ~, (1)(2)(3));
     }
   }
 
 #undef FIELD_COPY_CASE
 
   // TODO: Registrer and copy integral operators
 
   return copy;
 }
 
 std::unique_ptr<Residual>
 ModelFactory::createResidual(Model* model, Real sigma_y, Real hardening) {
   if (model->getType() != model_type::volume_2d)
     TAMAAS_EXCEPTION("Cannot instanciate model: " << model);
 
   return std::make_unique<ResidualTemplate<model_type::volume_2d>>(
       model, sigma_y, hardening);
 }
 
 #define MODEL_TYPE_CASE_MACRO(truc, arguments, type)                           \
   case type: {                                                                 \
     m.registerIntegralOperator<Mindlin<type, 2>>("mindlin_gradient");          \
     m.registerIntegralOperator<Boussinesq<type, 1>>("boussinesq_gradient");    \
     m.registerIntegralOperator<Mindlin<type, 1>>("mindlin");                   \
     m.registerIntegralOperator<Boussinesq<type, 0>>("boussinesq");             \
     break;                                                                     \
   }
 
 void ModelFactory::registerVolumeOperators(Model& m) {
   switch (m.getType()) {
     BOOST_PP_SEQ_FOR_EACH(MODEL_TYPE_CASE_MACRO, ~, (model_type::volume_2d));
   default:
     TAMAAS_EXCEPTION("Registering volume operators not supported on " << m);
   }
 }
 
 #undef MODEL_TYPE_CASE_MACRO
 
 }  // namespace tamaas
diff --git a/src/model/model_factory.hh b/src/model/model_factory.hh
index c0f1bad..3208097 100644
--- a/src/model/model_factory.hh
+++ b/src/model/model_factory.hh
@@ -1,57 +1,58 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MODEL_FACTORY_HH
 #define MODEL_FACTORY_HH
 /* -------------------------------------------------------------------------- */
 #include "be_engine.hh"
 #include "model.hh"
 #include "model_type.hh"
 #include "residual.hh"
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Factory class for model
  */
 class ModelFactory {
 public:
   /// Create new model
   static std::unique_ptr<Model>
   createModel(model_type type, const std::vector<Real>& system_size,
               const std::vector<UInt>& discretization);
 
   /// Make a deep copy of existing model
   static std::unique_ptr<Model> createModel(const Model& model);
 
   /// Create a plasticity residual
   static std::unique_ptr<Residual> createResidual(Model* model, Real sigma_y,
                                                   Real hardening);
 
   /// Register volume integral operators in a model
   static void registerVolumeOperators(Model& m);
 };
 
 }  // namespace tamaas
 
 #endif  // MODEL_FACTORY_HH
diff --git a/src/model/model_template.cpp b/src/model/model_template.cpp
index 3f9f677..3fb75da 100644
--- a/src/model/model_template.cpp
+++ b/src/model/model_template.cpp
@@ -1,163 +1,164 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "model_template.hh"
 #include "computes.hh"
 #include "hooke.hh"
 #include "influence.hh"
 #include "partitioner.hh"
 #include "westergaard.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 namespace detail {
 template <class Compute_t>
 class ComputeOperator : public IntegralOperator {
 public:
   /// Constructor
   ComputeOperator(Model* model) : IntegralOperator(model) {}
 
   IntegralOperator::kind getKind() const override {
     return IntegralOperator::dirac;
   }
   model_type getType() const override { return model->getType(); }
   void updateFromModel() override {}
 
   /// Apply functor
   void apply(GridBase<Real>& in, GridBase<Real>& out) const override {
     applyCompute<Compute_t>(model->getType(), out, in);
   }
 };
 }  // namespace detail
 
 template <model_type type>
 ModelTemplate<type>::ModelTemplate(std::vector<Real> system_size,
                                    std::vector<UInt> discretization)
     : Model(std::move(system_size), std::move(discretization)) {
   constexpr UInt dim = trait::dimension;
   constexpr UInt dim_b = trait::boundary_dimension;
   constexpr UInt nb_components = trait::components;
 
   if (this->system_size.size() != dim)
     TAMAAS_EXCEPTION("System size does not match model type");
   if (this->discretization.size() != dim)
     TAMAAS_EXCEPTION("Discretization size does not match model type");
 
   // Copying sizes for traction grid
   std::array<UInt, dim_b> traction_size;
   auto disc_it = this->discretization.begin() + (dim > dim_b);
   std::copy(disc_it, this->discretization.end(), traction_size.begin());
 
   // Adjust MPI sizes
   traction_size = Partitioner<dim_b>::local_size(traction_size);
   *disc_it = traction_size.front();
 
   // Allocating
   auto traction =
       std::make_unique<Grid<Real, dim_b>>(traction_size, nb_components);
   auto displacement =
       std::make_unique<Grid<Real, dim>>(this->discretization, nb_components);
 
   registerField("traction", std::move(traction));
   registerField("displacement", std::move(displacement));
 
   this->initializeBEEngine();
   registerIntegralOperator<Hooke<type>>("hooke");
   registerIntegralOperator<detail::ComputeOperator<compute::Eigenvalues>>(
       "eigenvalues");
   registerIntegralOperator<detail::ComputeOperator<compute::VonMises>>(
       "von_mises");
   registerIntegralOperator<detail::ComputeOperator<compute::Deviatoric>>(
       "deviatoric");
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void ModelTemplate<type>::initializeBEEngine() {
   engine = std::make_unique<BEEngineTmpl<type>>(this);
 }
 
 namespace {
 template <typename T>
 std::vector<T> extract(const std::vector<T>& v, UInt n) {
   std::vector<T> ex(v.size() - n);
   std::copy(v.begin() + n, v.end(), ex.begin());
   return ex;
 }
 }  // namespace
 
 /// \cond DO_NOT_DOCUMENT
 template <model_type type>
 std::vector<UInt> ModelTemplate<type>::getGlobalDiscretization() const {
   auto global_bdisc = Partitioner<trait::boundary_dimension>::global_size(
       getBoundaryDiscretization());
   if (trait::dimension != trait::boundary_dimension)
     global_bdisc.insert(global_bdisc.begin(), getDiscretization().front());
   return global_bdisc;
 }
 
 template <model_type type>
 std::vector<UInt> ModelTemplate<type>::getBoundaryDiscretization() const {
   return getDiscretization();
 }
 
 template <>
 std::vector<UInt>
 ModelTemplate<model_type::volume_1d>::getBoundaryDiscretization() const {
   return extract(getDiscretization(), 1);
 }
 
 template <>
 std::vector<UInt>
 ModelTemplate<model_type::volume_2d>::getBoundaryDiscretization() const {
   return extract(getDiscretization(), 1);
 }
 
 template <model_type type>
 std::vector<Real> ModelTemplate<type>::getBoundarySystemSize() const {
   return getSystemSize();
 }
 
 template <>
 std::vector<Real>
 ModelTemplate<model_type::volume_1d>::getBoundarySystemSize() const {
   return extract(getSystemSize(), 1);
 }
 
 template <>
 std::vector<Real>
 ModelTemplate<model_type::volume_2d>::getBoundarySystemSize() const {
   return extract(getSystemSize(), 1);
 }
 /// \endcond
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation                                                     */
 /* -------------------------------------------------------------------------- */
 template class ModelTemplate<model_type::basic_1d>;
 template class ModelTemplate<model_type::basic_2d>;
 template class ModelTemplate<model_type::surface_1d>;
 template class ModelTemplate<model_type::surface_2d>;
 template class ModelTemplate<model_type::volume_1d>;
 template class ModelTemplate<model_type::volume_2d>;
 
 }  // namespace tamaas
diff --git a/src/model/model_template.hh b/src/model/model_template.hh
index a71ca65..85a41a6 100644
--- a/src/model/model_template.hh
+++ b/src/model/model_template.hh
@@ -1,67 +1,68 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MODEL_TEMPLATE_HH
 #define MODEL_TEMPLATE_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_view.hh"
 #include "model.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /**
  * @brief Model class templated with model type
  * Specializations of this class should take care of dimension specific code
  */
 template <model_type type>
 class ModelTemplate : public Model {
   using trait = model_type_traits<type>;
   static constexpr UInt dim = trait::dimension;
   using ViewType = GridView<Grid, Real, dim, trait::boundary_dimension>;
 
 public:
   /// Constructor
   ModelTemplate(std::vector<Real> system_size,
                 std::vector<UInt> discretization);
 
   // Get model type
   model_type getType() const override { return type; }
 
   std::vector<UInt> getGlobalDiscretization() const override;
   std::vector<UInt> getBoundaryDiscretization() const override;
   std::vector<Real> getBoundarySystemSize() const override;
 
   bool isBoundaryField(const GridBase<Real>& field) const override {
     return field.getDimension() == trait::boundary_dimension;
   }
 
 protected:
   void initializeBEEngine();
 
 protected:
   std::unique_ptr<ViewType> displacement_view = nullptr;
   std::unique_ptr<ViewType> traction_view = nullptr;
 };
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // MODEL_TEMPLATE_HH
diff --git a/src/model/model_type.cpp b/src/model/model_type.cpp
index 5fa37de..58f7dbc 100644
--- a/src/model/model_type.cpp
+++ b/src/model/model_type.cpp
@@ -1,42 +1,43 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 const std::vector<UInt> model_type_traits<model_type::basic_1d>::indices = {};
 const std::vector<UInt> model_type_traits<model_type::basic_2d>::indices = {};
 const std::vector<UInt> model_type_traits<model_type::surface_1d>::indices = {};
 const std::vector<UInt> model_type_traits<model_type::surface_2d>::indices = {};
 const std::vector<UInt> model_type_traits<model_type::volume_1d>::indices = {0};
 const std::vector<UInt> model_type_traits<model_type::volume_2d>::indices = {0};
 
 constexpr char model_type_traits<model_type::basic_1d>::repr[];
 constexpr char model_type_traits<model_type::basic_2d>::repr[];
 constexpr char model_type_traits<model_type::surface_1d>::repr[];
 constexpr char model_type_traits<model_type::surface_2d>::repr[];
 constexpr char model_type_traits<model_type::volume_1d>::repr[];
 constexpr char model_type_traits<model_type::volume_2d>::repr[];
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/model/model_type.hh b/src/model/model_type.hh
index ef439ef..7e64b72 100644
--- a/src/model/model_type.hh
+++ b/src/model/model_type.hh
@@ -1,179 +1,180 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef MODEL_TYPE_HH
 #define MODEL_TYPE_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_base.hh"
 #include "static_types.hh"
 #include "tamaas.hh"
 #include <algorithm>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/seq.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <memory>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 // clang-format off
 /// Models types **for printing only** \cond HIDDEN_SYMBOLS
 #define TAMAAS_MODEL_TYPES			\
   (basic_1d)					          \
   (basic_2d)					          \
   (surface_1d)					        \
   (surface_2d)					        \
   (volume_1d)					          \
   (volume_2d)
 // clang-format on
 /// \endcond
 
 /// Types for grid dimensions and number of components
 enum class model_type {
   basic_1d,    ///< one component line
   basic_2d,    ///< one component surface
   surface_1d,  ///< two components line
   surface_2d,  ///< three components surface
   volume_1d,   ///< two components volume
   volume_2d    ///< three components volume
 };
 
 /// Trait class to store physical dimension of domain, of boundary and
 /// number of components
 template <model_type type>
 struct model_type_traits {};
 
 #define MODEL_TYPE_TRAITS_MACRO(type, dim, comp, bdim)                         \
   template <>                                                                  \
   struct model_type_traits<model_type::type> {                                 \
     static constexpr char repr[]{#type};                                       \
     static constexpr UInt dimension = dim;                                     \
     static constexpr UInt components = comp;                                   \
     static constexpr UInt boundary_dimension = bdim;                           \
     static constexpr UInt voigt = voigt_size<comp>::value;                     \
     static const std::vector<UInt> indices;                                    \
   }
 
 MODEL_TYPE_TRAITS_MACRO(basic_1d, 1, 1, 1);
 MODEL_TYPE_TRAITS_MACRO(basic_2d, 2, 1, 2);
 
 MODEL_TYPE_TRAITS_MACRO(surface_1d, 1, 2, 1);
 MODEL_TYPE_TRAITS_MACRO(surface_2d, 2, 3, 2);
 
 MODEL_TYPE_TRAITS_MACRO(volume_1d, 2, 2, 1);
 MODEL_TYPE_TRAITS_MACRO(volume_2d, 3, 3, 2);
 
 #undef MODEL_TYPE_TRAITS_MACRO
 
 /// \cond DO_NOT_DOCUMENT
 namespace detail {
 template <model_type type, bool boundary>
 struct dim_choice
     : std::integral_constant<
           UInt, (boundary) ? model_type_traits<type>::boundary_dimension
                            : model_type_traits<type>::dimension> {};
 }  // namespace detail
 /// \endcond
 
 template <model_type type, bool boundary, typename T, typename Container>
 std::unique_ptr<Grid<T, detail::dim_choice<type, boundary>::value>>
 allocateGrid(Container&& n, UInt nc) {
   return std::make_unique<Grid<T, detail::dim_choice<type, boundary>::value>>(
       std::begin(n), std::end(n), nc);
 }
 
 /// \cond HIDDEN_SYMBOLS
 #define ALLOC_GRID_CASE_MACRO(a, data, type)                                   \
   case data::type: {                                                           \
     ptr = allocateGrid<data::type, boundary, T>(                               \
         n, model_type_traits<data::type>::components);                         \
     break;                                                                     \
   }
 /// \endcond
 
 /// Helper function for grid allocation
 template <bool boundary, typename T, typename Container>
 std::unique_ptr<GridBase<T>> allocateGrid(model_type type, Container&& n) {
   std::unique_ptr<GridBase<T>> ptr = nullptr;
 
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(ALLOC_GRID_CASE_MACRO, model_type,
                           TAMAAS_MODEL_TYPES);
   }
 
   return ptr;
 }
 
 #undef ALLOC_GRID_CASE_MACRO
 
 #define ALLOC_GRID_CASE_MACRO(a, data, type)                                   \
   case data::type: {                                                           \
     ptr = allocateGrid<data::type, boundary, T>(n, nc);                        \
     break;                                                                     \
   }
 
 /// Helper function for grid allocation with
 /// non-standard components
 template <bool boundary, typename T, typename Container>
 std::unique_ptr<GridBase<T>> allocateGrid(model_type type, Container&& n,
                                           UInt nc) {
   std::unique_ptr<GridBase<T>> ptr = nullptr;
 
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(ALLOC_GRID_CASE_MACRO, model_type,
                           TAMAAS_MODEL_TYPES);
   }
 
   return ptr;
 }
 
 /// Print function for model_type
 inline std::ostream& operator<<(std::ostream& o, const model_type& val) {
   switch (val) {
 #define PRINT_MODEL_TYPE(r, data, type)                                        \
   case data::type:                                                             \
     o << model_type_traits<data::type>::repr;                                  \
     break;
     BOOST_PP_SEQ_FOR_EACH(PRINT_MODEL_TYPE, model_type, TAMAAS_MODEL_TYPES);
 #undef PRINT_MODEL_TYPE
   }
   return o;
 }
 
 #undef ALLOC_GRID_CASE_MACRO
 
 // clang-format off
 #ifdef TAMAAS_MODEL_TYPES
 #undef TAMAAS_MODEL_TYPES
 #endif
 #define TAMAAS_MODEL_TYPES			\
   (model_type::basic_1d)			\
   (model_type::basic_2d)			\
   (model_type::surface_1d)			\
   (model_type::surface_2d)			\
   (model_type::volume_1d)			\
   (model_type::volume_2d)
 // clang-format on
 
 }  // namespace tamaas
 /* --------------------------------------------------------------------------
  */
 #endif  // MODEL_TYPE_HH
diff --git a/src/model/volume_potential.cpp b/src/model/volume_potential.cpp
index 6c7cb7e..3e8b453 100644
--- a/src/model/volume_potential.cpp
+++ b/src/model/volume_potential.cpp
@@ -1,114 +1,115 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "volume_potential.hh"
 #include "model.hh"
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 template <model_type type>
 VolumePotential<type>::VolumePotential(Model* model)
     : IntegralOperator(model), wavevectors(), source_buffer(), out_buffer(),
       engine(FFTEngine::makeEngine()) {
   // Copy horizontal sizes
   std::array<UInt, trait::boundary_dimension> sizes;
   std::copy(model->getDiscretization().begin() + 1,
             model->getDiscretization().end(), sizes.begin());
 
   auto hermitian_sizes =
       GridHermitian<Real, trait::boundary_dimension>::hermitianDimensions(
           sizes);
 
   wavevectors =
       FFTEngine::template computeFrequencies<Real, trait::boundary_dimension,
                                              true>(hermitian_sizes);
 
   // Normalize wavevectors
   auto system_size = model->getBoundarySystemSize();
   VectorProxy<const Real, trait::boundary_dimension> boundary_domain{
       system_size[0]};
   wavevectors *= 2 * M_PI;
   wavevectors /= boundary_domain;
   wavevectors *= -1.;  // < this is important for the convolution computation
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 model_type VolumePotential<type>::getType() const {
   return this->model->getType();
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void VolumePotential<type>::initialize(UInt source_components,
                                        UInt out_components,
                                        UInt out_buffer_size) {
   auto hermitian_sizes =
       GridHermitian<Real, trait::boundary_dimension>::hermitianDimensions(
           this->model->getBoundaryDiscretization());
 
   // Initializing buffers
   this->source_buffer.resize(this->model->getDiscretization()[0]);
   this->out_buffer.resize(out_buffer_size);
 
   // Resizing source buffer
   std::for_each(this->source_buffer.begin(), this->source_buffer.end(),
                 [&](auto& buffer) {
                   buffer.setNbComponents(source_components);
                   buffer.resize(hermitian_sizes);
                 });
 
   // Resizing output buffer
   std::for_each(this->out_buffer.begin(), this->out_buffer.end(),
                 [&](auto& buffer) {
                   buffer.setNbComponents(out_components);
                   buffer.resize(hermitian_sizes);
                 });
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type>
 void VolumePotential<type>::transformSource(GridBase<Real>& in,
                                             filter_t pred) const {
   constexpr UInt dim = trait::dimension;
   auto& i = dynamic_cast<Grid<Real, dim>&>(in);
 
   // Transforming source
   for (UInt layer : Loop::range(i.sizes().front())) {
     if (not pred(layer))
       continue;
 
     auto in_layer = make_view(i, layer);
     engine->forward(in_layer, source_buffer[layer]);
   }
 
   for (auto&& layer : out_buffer)
     layer = 0;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation */
 /* -------------------------------------------------------------------------- */
 template class VolumePotential<model_type::volume_1d>;
 template class VolumePotential<model_type::volume_2d>;
 
 }  // namespace tamaas
diff --git a/src/model/volume_potential.hh b/src/model/volume_potential.hh
index 5debff0..819a609 100644
--- a/src/model/volume_potential.hh
+++ b/src/model/volume_potential.hh
@@ -1,138 +1,139 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef VOLUME_POTENTIAL_HH
 #define VOLUME_POTENTIAL_HH
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "grid_hermitian.hh"
 #include "grid_view.hh"
 #include "integral_operator.hh"
 #include "logger.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 #include <functional>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /// Trait type for component management
 template <UInt derivative>
 struct derivative_traits;
 
 template <>
 struct derivative_traits<0> {
   template <model_type type>
   static constexpr UInt source_components = model_type_traits<type>::components;
   template <model_type type>
   static constexpr UInt out_components = model_type_traits<type>::components;
 };
 
 template <>
 struct derivative_traits<1> {
   template <model_type type>
   static constexpr UInt source_components = model_type_traits<type>::voigt;
   template <model_type type>
   static constexpr UInt out_components = model_type_traits<type>::components;
 };
 
 template <>
 struct derivative_traits<2> {
   template <model_type type>
   static constexpr UInt source_components = model_type_traits<type>::voigt;
   template <model_type type>
   static constexpr UInt out_components = model_type_traits<type>::voigt;
 };
 
 /**
  * @brief Volume potential operator class. Applies the operators for computation
  * of displacements and strains due to residual/eigen strains
  */
 template <model_type type>
 class VolumePotential : public IntegralOperator {
   using trait = model_type_traits<type>;
 
 protected:
   using filter_t = const std::function<bool(UInt)>&;
 
 public:
   VolumePotential(Model* model);
 
   /// Update from model (does nothing)
   void updateFromModel() override {}
 
   /// Kind
   IntegralOperator::kind getKind() const override {
     return IntegralOperator::neumann;
   }
 
   /// Type
   model_type getType() const override;
 
   /// Apply to all of the source layers
   void apply(GridBase<Real>& input, GridBase<Real>& output) const override {
     applyIf(input, output, [](UInt) { return true; });
   }
 
 protected:
   /// Transform source layer-by-layer
   void transformSource(GridBase<Real>& in, filter_t pred) const;
   /// Transform all source
   void transformSource(GridBase<Real>& in) const {
     transformSource(in, [](auto) { return true; });
   }
   /// Transform output layer-by-layer
   template <typename Func>
   void transformOutput(Func func, GridBase<Real>& out) const;
 
   /// Initialize fourier buffers
   void initialize(UInt source_components, UInt out_components,
                   UInt out_buffer_size);
 
 protected:
   Grid<Real, trait::boundary_dimension> wavevectors;
   using BufferType = GridHermitian<Real, trait::boundary_dimension>;
   mutable std::vector<BufferType> source_buffer;
   mutable std::vector<BufferType> out_buffer;
   mutable std::unique_ptr<FFTEngine> engine;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Template implementation */
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 template <typename Func>
 void VolumePotential<type>::transformOutput(Func func,
                                             GridBase<Real>& out) const {
   constexpr UInt dim = trait::dimension;
   auto& o = dynamic_cast<Grid<Real, dim>&>(out);
 
   // Transforming output
   for (UInt layer : Loop::range(o.sizes().front())) {
     auto out_layer = make_view(o, layer);
     auto& fourier_out_layer = func(out_buffer, layer);
     engine->backward(out_layer, fourier_out_layer);
   }
 }
 
 }  // namespace tamaas
 
 #endif  // VOLUME_POTENTIAL_HH
diff --git a/src/model/westergaard.cpp b/src/model/westergaard.cpp
index d2ffc7c..30ced2d 100644
--- a/src/model/westergaard.cpp
+++ b/src/model/westergaard.cpp
@@ -1,305 +1,306 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "grid_view.hh"
 #include "influence.hh"
 #include "loop.hh"
 #include "model.hh"
 #include "static_types.hh"
 
 #include "westergaard.hh"
 
 #include <functional>
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <model_type mtype, IntegralOperator::kind otype>
 Westergaard<mtype, otype>::Westergaard(Model* model)
     : IntegralOperator(model), influence(), buffer(),
       engine(FFTEngine::makeEngine()) {
   // Copy sizes
   auto bdisc = model->getBoundaryDiscretization();
 
   auto boundary_hermitian_sizes =
       GridHermitian<Real, trait::boundary_dimension>::hermitianDimensions(
           bdisc);
 
   constexpr UInt nb_components = trait::components;
 
   buffer.setNbComponents(nb_components);
   buffer.resize(boundary_hermitian_sizes);
   influence.setNbComponents(nb_components * nb_components);
   influence.resize(boundary_hermitian_sizes);
   initInfluence();
 }
 
 /* -------------------------------------------------------------------------- */
 
 namespace detail {
 template <UInt m, UInt j>
 struct boundary_fft_helper {
   template <typename Buffer, typename Out>
   static void backwardTransform(FFTEngine& e, Buffer&& buffer, Out&& out) {
     auto view = make_view(out, 0);
     e.backward(view, buffer);
   }
 };
 
 template <UInt m>
 struct boundary_fft_helper<m, m> {
   template <typename Buffer, typename Out>
   static void backwardTransform(FFTEngine& e, Buffer&& buffer, Out&& out) {
     e.backward(out, buffer);
   }
 };
 }  // namespace detail
 
 template <model_type mtype, IntegralOperator::kind otype>
 template <typename Functor>
 void Westergaard<mtype, otype>::fourierApply(Functor func, GridBase<Real>& in,
                                              GridBase<Real>& out) const try {
   auto& i = dynamic_cast<Grid<Real, bdim>&>(in);
   auto& full_out = dynamic_cast<Grid<Real, dim>&>(out);
 
   engine->forward(i, buffer);
 
   /// Applying influence
   func(buffer, influence);
 
   /// Backward fourier transform on boundary only
   detail::boundary_fft_helper<bdim, dim>::backwardTransform(*engine, buffer,
                                                             full_out);
 
 } catch (const std::bad_cast& e) {
   TAMAAS_EXCEPTION("Neumann and dirichlet types do not match model type");
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <model_type mtype, IntegralOperator::kind otype>
 template <typename Functor>
 void Westergaard<mtype, otype>::initFromFunctor(Functor func) {
   // Compute wavevectors for influence
   auto wavevectors = FFTEngine::template computeFrequencies<Real, bdim, true>(
       influence.sizes());
   // Get boundary physical size
   auto system_size = this->model->getBoundarySystemSize();
   VectorProxy<const Real, bdim> domain(system_size[0]);
 
   // Normalize wavevectors
   wavevectors *= 2 * M_PI;
   wavevectors /= domain;
 
   // Apply functor
   Loop::loop(func, range<VectorProxy<Real, bdim>>(wavevectors),
              range<MatrixProxy<Complex, comp, comp>>(influence));
 
   if (mpi::rank() == 0) {
     // Set fundamental mode to zero
     MatrixProxy<Complex, comp, comp> mat(influence(0));
     mat = 0;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// \cond DO_NOT_DOCUMENT
 #define NEUMANN_BASIC(type)                                                    \
   template <>                                                                  \
   void Westergaard<type, IntegralOperator::neumann>::initInfluence() {         \
     auto E_star = model->getHertzModulus();                                    \
     auto basic = [E_star] CUDA_LAMBDA(VectorProxy<Real, bdim> q,               \
                                       MatrixProxy<Complex, comp, comp> k) {    \
       k(0, 0) = 2. / (E_star * q.l2norm());                                    \
     };                                                                         \
     initFromFunctor(basic);                                                    \
   }
 #define DIRICHLET_BASIC(type)                                                  \
   template <>                                                                  \
   void Westergaard<type, IntegralOperator::dirichlet>::initInfluence() {       \
     auto E_star = model->getHertzModulus();                                    \
     auto basic = [E_star] CUDA_LAMBDA(VectorProxy<Real, bdim> q,               \
                                       MatrixProxy<Complex, comp, comp> k) {    \
       k(0, 0) = E_star * q.l2norm() / 2;                                       \
     };                                                                         \
     initFromFunctor(basic);                                                    \
   }
 
 NEUMANN_BASIC(model_type::basic_1d)
 NEUMANN_BASIC(model_type::basic_2d)
 DIRICHLET_BASIC(model_type::basic_1d)
 DIRICHLET_BASIC(model_type::basic_2d)
 
 #undef NEUMANN_BASIC
 #undef DIRICHLET_BASIC
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 void Westergaard<model_type::surface_1d,
                  IntegralOperator::neumann>::initInfluence() {
   auto E = model->getYoungModulus();
   auto nu = model->getPoissonRatio();
   const Complex I(0, 1);
   auto surface = [E, nu, I] CUDA_LAMBDA(VectorProxy<Real, bdim> q_,
                                         MatrixProxy<Complex, comp, comp> F) {
     Real q = q_(0);
     q *= 1. / q_.l2norm();
 
     F(0, 0) = 2 * (1 + nu) * (1 - nu * q * q);
     F(1, 1) = 2 * (1 - nu * nu);
 
     F(0, 1) = I * q * (1 + nu) * (1 - 2 * nu);
     F(1, 0) = -F(0, 1);
 
     F *= 1. / (E * q_.l2norm());
   };
 
   initFromFunctor(surface);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 void Westergaard<model_type::surface_2d,
                  IntegralOperator::neumann>::initInfluence() {
   auto E = model->getYoungModulus();
   auto nu = model->getPoissonRatio();
   const Complex I(0, 1);
   auto surface = [E, nu, I] CUDA_LAMBDA(VectorProxy<Real, bdim> q_,
                                         MatrixProxy<Complex, comp, comp> F) {
     Vector<Real, bdim> q(q_);
     q *= 1 / q_.l2norm();
 
     F(0, 0) = 2 * (1 + nu) * (1 - nu * q(0) * q(0));
     F(1, 1) = 2 * (1 + nu) * (1 - nu * q(1) * q(1));
     F(2, 2) = 2 * (1 - nu * nu);
 
     F(0, 1) = F(1, 0) = -q(0) * q(1) * 2 * nu * (1 + nu);
 
     F(0, 2) = I * q(0) * (1 + nu) * (1. - 2. * nu);
     F(1, 2) = I * q(1) * (1 + nu) * (1. - 2. * nu);
 
     F(2, 0) = -F(0, 2);
     F(2, 1) = -F(1, 2);
 
     F *= 1. / (E * q_.l2norm());
   };
 
   initFromFunctor(surface);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type mtype, IntegralOperator::kind otype>
 void Westergaard<mtype, otype>::initInfluence() {}
 /// \endcond
 
 /* ------------------------------------------------------------------------ */
 template <model_type mtype, IntegralOperator::kind otype>
 void Westergaard<mtype, otype>::apply(GridBase<Real>& input,
                                       GridBase<Real>& output) const {
   auto apply = [](decltype(buffer)& buffer,
                   const decltype(influence)& influence) {
     Loop::loop(
         [] CUDA_LAMBDA(VectorProxy<Complex, comp> i,
                        MatrixProxy<const Complex, comp, comp> F) { i = F * i; },
         range<VectorProxy<Complex, comp>>(buffer),
         range<MatrixProxy<const Complex, comp, comp>>(influence));
   };
   fourierApply(apply, input, output);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type, IntegralOperator::kind otype>
 Real Westergaard<type, otype>::getOperatorNorm() {
   constexpr UInt comp = model_type_traits<type>::components;
   Real _norm = 0.0;
 
   _norm = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(MatrixProxy<Complex, comp, comp> m) {
         Real n = thrust::norm(m.l2squared());
         return std::isnan(n) ? 0 : n;
       },
       range<MatrixProxy<Complex, comp, comp>>(influence));
 
   auto size = model->getSystemSize();
   auto disc = model->getDiscretization();
   auto dim = model_type_traits<type>::dimension;
 
   /// TODO: why?
   switch (dim) {
   case 1:
     _norm /= (size[0] / disc[0]) * (size[0] / disc[0]);
     break;
   default:
     for (UInt i = 0; i < dim; i++) {
       _norm /= size[i] / disc[i];
     }
   }
 
   return std::sqrt(_norm);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type, IntegralOperator::kind otype>
 std::pair<UInt, UInt> Westergaard<type, otype>::matvecShape() const {
   auto n = model->getBoundaryDiscretization();
   auto N = std::accumulate(n.begin(), n.end(), comp, std::multiplies<>());
   return std::make_pair(N, N);
 }
 
 /* -------------------------------------------------------------------------- */
 template <model_type type, IntegralOperator::kind otype>
 GridBase<Real> Westergaard<type, otype>::matvec(GridBase<Real>& X) const {
   auto n = model->getBoundaryDiscretization();
   // Creating correct input
   Grid<Real, bdim> x(n, comp);
   thrust::copy(X.begin(), X.end(), x.begin());
 
   // Creating correct output
   if (bdim != dim)
     n.insert(n.begin(), 1);
 
   Grid<Real, dim> y(n, comp);
   apply(x, y);
   return std::move(y);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Template instanciation */
 /* -------------------------------------------------------------------------- */
 template class Westergaard<model_type::basic_1d, IntegralOperator::neumann>;
 template class Westergaard<model_type::basic_2d, IntegralOperator::neumann>;
 template class Westergaard<model_type::basic_1d, IntegralOperator::dirichlet>;
 template class Westergaard<model_type::basic_2d, IntegralOperator::dirichlet>;
 template class Westergaard<model_type::surface_1d, IntegralOperator::neumann>;
 template class Westergaard<model_type::surface_2d, IntegralOperator::neumann>;
 template class Westergaard<model_type::surface_1d, IntegralOperator::dirichlet>;
 template class Westergaard<model_type::surface_2d, IntegralOperator::dirichlet>;
 template class Westergaard<model_type::volume_1d, IntegralOperator::neumann>;
 template class Westergaard<model_type::volume_2d, IntegralOperator::neumann>;
 template class Westergaard<model_type::volume_1d, IntegralOperator::dirichlet>;
 template class Westergaard<model_type::volume_2d, IntegralOperator::dirichlet>;
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/model/westergaard.hh b/src/model/westergaard.hh
index ebe9168..1373a17 100644
--- a/src/model/westergaard.hh
+++ b/src/model/westergaard.hh
@@ -1,96 +1,97 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef WESTERGAARD_HH
 #define WESTERGAARD_HH
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "grid_hermitian.hh"
 #include "integral_operator.hh"
 #include "model_type.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Operator based on Westergaard solution and the Dicrete Fourier
  * Transform.
  * This class is templated with model type to allow efficient storage of the
  * influence coefficients.
  * The integral operator is only applied to surface pressure/displacements,
  * even for volume models.
  */
 template <model_type mtype, IntegralOperator::kind otype>
 class Westergaard : public IntegralOperator {
   using trait = model_type_traits<mtype>;
   static constexpr UInt dim = trait::dimension;
   static constexpr UInt bdim = trait::boundary_dimension;
   static constexpr UInt comp = trait::components;
 
 public:
   /// Constuctor: initalizes influence coefficients and allocates buffer
   Westergaard(Model* model);
 
   /// Get influence coefficients
   const GridHermitian<Real, bdim>& getInfluence() const { return influence; }
 
   /// Apply influence coefficients to input
   void apply(GridBase<Real>& input, GridBase<Real>& output) const override;
 
   /// Update the influence coefficients
   void updateFromModel() override { initInfluence(); }
 
   /// Kind
   IntegralOperator::kind getKind() const override { return otype; }
 
   /// Type
   model_type getType() const override { return mtype; }
 
   /// Initialize influence coefficients
   void initInfluence();
 
   template <typename Functor>
   void initFromFunctor(Functor func);
 
   /// Apply a functor in Fourier space
   template <typename Functor>
   void fourierApply(Functor func, GridBase<Real>& in,
                     GridBase<Real>& out) const;
 
   /// Compute L_2 norm of influence functions
   Real getOperatorNorm() override;
 
   /// Dense shape
   std::pair<UInt, UInt> matvecShape() const override;
 
   /// Dense matvec
   GridBase<Real> matvec(GridBase<Real>& x) const override;
 
 public:
   GridHermitian<Real, bdim> influence;
   mutable GridHermitian<Real, bdim> buffer;
   mutable std::unique_ptr<FFTEngine> engine;
 };
 
 }  // namespace tamaas
 
 #endif  // WESTERGAARD_HH
diff --git a/src/percolation/flood_fill.cpp b/src/percolation/flood_fill.cpp
index 9a62afb..0228f05 100644
--- a/src/percolation/flood_fill.cpp
+++ b/src/percolation/flood_fill.cpp
@@ -1,257 +1,258 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "flood_fill.hh"
 #include "partitioner.hh"
 #include <algorithm>
 #include <limits>
 #include <stack>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 Int unsigned_modulo(Int i, UInt n) { return (i % n + n) % n; }
 
 template <std::size_t dim>
 std::array<UInt, dim> unsigned_modulo(const std::array<Int, dim>& t,
                                       const std::array<UInt, dim>& n) {
   std::array<UInt, dim> index;
   for (UInt i = 0; i < dim; ++i)
     index[i] = unsigned_modulo(t[i], n[i]);
   return index;
 }
 
 template <std::size_t dim>
 std::array<Int, dim> cast_int(const std::array<UInt, dim>& a) {
   std::array<Int, dim> r;
   for (UInt i = 0; i < dim; ++i)
     r[i] = (Int)a[i];
   return r;
 }
 
 template <UInt dim>
 Cluster<dim>::Cluster(const Cluster& other)
     : points(other.points), perimeter(other.perimeter) {}
 
 template <>
 auto Cluster<1>::getNextNeighbors(const std::array<UInt, 1>& p) {
   std::vector<Point> neighbors(2);
   Int i = p[0];
   neighbors[0] = {i - 1};
   neighbors[1] = {i + 1};
   return neighbors;
 }
 
 template <>
 auto Cluster<1>::getDiagonalNeighbors(const std::array<UInt, 1>& /*p*/) {
   return std::vector<Point>();
 }
 
 template <>
 auto Cluster<2>::getNextNeighbors(const std::array<UInt, 2>& p) {
   std::vector<Point> neighbors(4);
   Int i = p[0], j = p[1];
   neighbors[0] = {i + 1, j};
   neighbors[1] = {i - 1, j};
   neighbors[2] = {i, j - 1};
   neighbors[3] = {i, j + 1};
   return neighbors;
 }
 
 template <>
 auto Cluster<2>::getDiagonalNeighbors(const std::array<UInt, 2>& p) {
   std::vector<Point> neighbors(4);
   Int i = p[0], j = p[1];
   neighbors[0] = {i + 1, j + 1};
   neighbors[1] = {i - 1, j - 1};
   neighbors[2] = {i - 1, j + 1};
   neighbors[3] = {i + 1, j - 1};
   return neighbors;
 }
 
 template <>
 auto Cluster<3>::getNextNeighbors(const std::array<UInt, 3>& p) {
   std::vector<Point> neighbors(6);
   Int i = p[0], j = p[1], k = p[2];
   neighbors[0] = {i + 1, j, k};
   neighbors[1] = {i - 1, j, k};
   neighbors[2] = {i, j - 1, k};
   neighbors[3] = {i, j + 1, k};
   neighbors[4] = {i, j, k - 1};
   neighbors[5] = {i, j, k + 1};
   return neighbors;
 }
 
 template <>
 auto Cluster<3>::getDiagonalNeighbors(const std::array<UInt, 3>& p) {
   std::vector<Point> neighbors(20);
   Int i = p[0], j = p[1], k = p[2];
   // 8 corners
   neighbors[0] = {i + 1, j + 1, k + 1};
   neighbors[1] = {i + 1, j + 1, k - 1};
   neighbors[2] = {i + 1, j - 1, k + 1};
   neighbors[3] = {i + 1, j - 1, k - 1};
   neighbors[4] = {i - 1, j + 1, k + 1};
   neighbors[5] = {i - 1, j + 1, k - 1};
   neighbors[6] = {i - 1, j - 1, k + 1};
   neighbors[7] = {i - 1, j - 1, k - 1};
 
   // 4 diagonals in i = 0
   neighbors[8] = {i, j + 1, k + 1};
   neighbors[9] = {i, j + 1, k - 1};
   neighbors[10] = {i, j - 1, k + 1};
   neighbors[11] = {i, j - 1, k - 1};
 
   // 4 diagonals in j = 0
   neighbors[12] = {i + 1, j, k + 1};
   neighbors[13] = {i + 1, j, k - 1};
   neighbors[14] = {i - 1, j, k + 1};
   neighbors[15] = {i - 1, j, k - 1};
 
   // 4 diagonals in k = 0
   neighbors[16] = {i + 1, j + 1, k};
   neighbors[17] = {i + 1, j - 1, k};
   neighbors[18] = {i - 1, j + 1, k};
   neighbors[19] = {i - 1, j - 1, k};
   return neighbors;
 }
 
 template <UInt dim>
 std::pair<std::array<Int, dim>, std::array<Int, dim>>
 Cluster<dim>::boundingBox() const {
   // TODO make sure periodic boundaries are correctly unwrapped
   std::array<Int, dim> mins, maxs;
   mins.fill(std::numeric_limits<Int>::max());
   maxs.fill(std::numeric_limits<Int>::min());
 
   for (const auto& p : points)
     for (UInt i = 0; i < dim; ++i) {
       mins[i] = std::min(mins[i], p[i]);
       maxs[i] = std::max(maxs[i], p[i]);
     }
 
   return std::make_pair(mins, maxs);
 }
 
 template <UInt dim>
 Cluster<dim>::Cluster(Point start, const Grid<bool, dim>& map,
                       Grid<bool, dim>& visited, bool diagonal) {
   // Visiting stack
   std::stack<Point, std::vector<Point>> visiting;
   visiting.push(start);
   // Contact sizes
   const auto& n = map.sizes();
 
   while (not visiting.empty()) {
     auto p = unsigned_modulo(visiting.top(), n);
 
     if (visited(p)) {
       visiting.pop();
       continue;
     }
 
     visited(p) = true;
     points.push_back(visiting.top());
     visiting.pop();
 
     auto process = [&](const std::vector<Point>& neighbors,
                        const bool do_perimeter) {
       for (auto& p : neighbors) {
         auto index = unsigned_modulo(p, n);
         if (not visited(index) and map(index)) {
           visiting.push(cast_int(index));
         }
 
         if (do_perimeter and (not map(index)))
           ++perimeter;
       }
     };
 
     process(getNextNeighbors(p), true);
 
     if (diagonal) {
       process(getDiagonalNeighbors(p), false);
     }
   }
 }
 
 std::list<Cluster<1>> FloodFill::getSegments(const Grid<bool, 1>& map) {
   auto n = map.sizes();
   Grid<bool, 1> visited(n, 1);
   visited = false;
   std::list<Cluster<1>> clusters;
 
   for (UInt i = 0; i < n[0]; ++i) {
     if (map(i) && !visited(i)) {
       clusters.emplace_back(std::array<Int, 1>{(Int)i}, map, visited,
                             false);
     }
   }
 
   return clusters;
 }
 
 std::list<Cluster<2>> FloodFill::getClusters(const Grid<bool, 2>& map,
                                              bool diagonal) {
   auto global_contact = Partitioner<2>::gather(map);
   auto n = global_contact.sizes();
   Grid<bool, 2> visited(n, 1);
   visited = false;
   std::list<Cluster<2>> clusters;
 
   if (mpi::rank() == 0)
     for (UInt i = 0; i < n[0]; ++i) {
       for (UInt j = 0; j < n[1]; ++j) {
         if (global_contact(i, j) && !visited(i, j)) {
           clusters.emplace_back(std::array<Int, 2>{(Int)i, (Int)j},
                                 global_contact, visited, diagonal);
         }
       }
     }
 
   return clusters;
 }
 
 std::list<Cluster<3>> FloodFill::getVolumes(const Grid<bool, 3>& map,
                                             bool diagonal) {
   auto n = map.sizes();
   Grid<bool, 3> visited(n, 1);
   visited = false;
   std::list<Cluster<3>> clusters;
 
   for (UInt i = 0; i < n[0]; ++i) {
     for (UInt j = 0; j < n[1]; ++j) {
       for (UInt k = 0; k < n[2]; ++k) {
         if (map(i, j, k) && !visited(i, j, k)) {
           clusters.emplace_back(std::array<Int, 3>{(Int)i, (Int)j, (Int)k},
                                 map, visited, diagonal);
         }
       }
     }
   }
 
   return clusters;
 }
 
 template class Cluster<1>;
 template class Cluster<2>;
 template class Cluster<3>;
 
 }  // namespace tamaas
diff --git a/src/percolation/flood_fill.hh b/src/percolation/flood_fill.hh
index b28accf..c760b9d 100644
--- a/src/percolation/flood_fill.hh
+++ b/src/percolation/flood_fill.hh
@@ -1,76 +1,77 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef FLOOD_FILL_H
 #define FLOOD_FILL_H
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include <list>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 class Cluster {
   using Point = std::array<Int, dim>;
 
 public:
   /// Constructor
   Cluster(Point start, const Grid<bool, dim>& map, Grid<bool, dim>& visited,
           bool diagonal);
   /// Copy constructor
   Cluster(const Cluster& other);
   /// Default constructor
   Cluster() = default;
   /// Get area of cluster
   UInt getArea() const { return getPoints().size(); }
   /// Get perimeter of cluster
   UInt getPerimeter() const { return perimeter; }
   /// Get contact points
   const std::list<Point>& getPoints() const { return points; }
   /// Get bounding box
   std::pair<std::array<Int, dim>, std::array<Int, dim>> boundingBox() const;
   /// Assign next neighbors
   auto getNextNeighbors(const std::array<UInt, dim>& p);
   /// Assign diagonal neighbors
   auto getDiagonalNeighbors(const std::array<UInt, dim>& p);
 
 private:
   std::list<Point> points;
   UInt perimeter = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 
 class FloodFill {
 public:
   static std::list<Cluster<1>> getSegments(const Grid<bool, 1>& map);
   /// Returns a list of clusters from a boolean contact map
   static std::list<Cluster<2>> getClusters(const Grid<bool, 2>& map,
                                            bool diagonal);
   static std::list<Cluster<3>> getVolumes(const Grid<bool, 3>& map,
                                           bool diagonal);
 };
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // FLOOD_FILL_H
diff --git a/src/solvers/beck_teboulle.cpp b/src/solvers/beck_teboulle.cpp
index 637b2da..8f7563d 100644
--- a/src/solvers/beck_teboulle.cpp
+++ b/src/solvers/beck_teboulle.cpp
@@ -1,107 +1,108 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "beck_teboulle.hh"
 #include "logger.hh"
 #include <iomanip>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 BeckTeboulle::BeckTeboulle(Model& model, const GridBase<Real>& surface,
                            Real tolerance, Real mu)
     : Kato(model, surface, tolerance, mu) {}
 
 /* -------------------------------------------------------------------------- */
 
 Real BeckTeboulle::solve(GridBase<Real>& g0) {
   if (g0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean gap does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveTmpl<model_type::surface_1d>(g0);
     break;
   case model_type::surface_2d:
     cost = solveTmpl<model_type::surface_2d>(g0);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real BeckTeboulle::solveTmpl(GridBase<Real>& g0) {
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0;
   UInt n = 0;
   *pressure = 0;
   GridBase<Real> z(*pressure);
   GridBase<Real> pressure_old(*pressure);
   Real t0 = 1;
   Real t1 = 1;
   Real m = 0;
   Real lipschitz = engine.getNeumannNorm();
 
   do {
     engine.solveNeumann(*pressure, *gap);
     addUniform<comp>(*gap, g0);
     *gap -= *surfaceComp;
 
     z = *gap;
     z /= -lipschitz;
     *pressure += z;
     enforcePressureCoulomb<comp>();
     z = *pressure;
 
     t1 = 1 + std::sqrt(4 * t0 * t0 + 1) / 2;
     m = 1 + (t0 - 1) / t1;
     z -= pressure_old;
     z *= m;
     z += pressure_old;
 
     t0 = t1;
     pressure_old = *pressure;
 
     cost = computeCost();
     printState(n, cost, cost);
   } while (cost > this->tolerance && n++ < this->max_iterations);
 
   computeFinalGap<comp>();
 
   return cost;
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/beck_teboulle.hh b/src/solvers/beck_teboulle.hh
index 409e590..fa26392 100644
--- a/src/solvers/beck_teboulle.hh
+++ b/src/solvers/beck_teboulle.hh
@@ -1,47 +1,48 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef BECK_TEBOULLE_HH
 #define BECK_TEBOULLE_HH
 /* -------------------------------------------------------------------------- */
 #include "kato.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class BeckTeboulle : public Kato {
 public:
   /// Constructor
   BeckTeboulle(Model& model, const GridBase<Real>& surface, Real tolerance,
                Real mu);
 
 public:
   /// Solve
   Real solve(GridBase<Real>& g0);
 
 private:
   /// Template for solve function
   template <model_type type>
   Real solveTmpl(GridBase<Real>& g0);
 };
 
 }  // namespace tamaas
 
 #endif  // BECK_TEBOULLE_HH
diff --git a/src/solvers/condat.cpp b/src/solvers/condat.cpp
index 684dadf..969ca2c 100644
--- a/src/solvers/condat.cpp
+++ b/src/solvers/condat.cpp
@@ -1,151 +1,152 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "condat.hh"
 #include "logger.hh"
 #include <iomanip>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 Condat::Condat(Model& model, const GridBase<Real>& surface, Real tolerance,
                Real mu)
     : Kato(model, surface, tolerance, mu) {
   pressure_old =
       allocateGrid<true, Real>(model.getType(), model.getDiscretization(),
                                model.getTraction().getNbComponents());
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Condat::solve(GridBase<Real>& p0, Real grad_step) {
   if (p0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean pressure does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveTmpl<model_type::surface_1d>(p0, grad_step);
     break;
   case model_type::surface_2d:
     cost = solveTmpl<model_type::surface_2d>(p0, grad_step);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real Condat::solveTmpl(GridBase<Real>& p0, Real grad_step) {
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0;
   UInt n = 0;
   pressure->uniformSetComponents(p0);
   *pressure_old = 0;
   Grid<Real, 1> q({1}, comp);
   q = 0;
 
   Real lipschitz = engine.getNeumannNorm();
   Real sigma = 2 * grad_step / lipschitz;
 
   Vector<Real, comp> h_mean = computeMean<comp>(*surfaceComp);
   *surfaceComp -= h_mean;
 
   do {
     updateGap<comp>(sigma, grad_step, q);
     *pressure -= *gap;
     enforcePressureCoulomb<comp>();
     updateLagrange<comp>(q, p0);
     *pressure_old = *pressure;
 
     cost = computeCost();
     printState(n, cost, cost);
   } while ((cost > this->tolerance || cost == 0.0) &&
            n++ < this->max_iterations);
 
   *surfaceComp += h_mean;
   computeFinalGap<comp>();
 
   return cost;
 }
 
 /* -------------------------------------------------------------------------- */
 
 // template <UInt comp>
 // void Condat::updateGap(Real sigma, Real grad_step, GridBase<Real>& q) {
 //   engine.solveNeumann(*pressure, *gap);
 
 //   VectorProxy<Real, comp> _q = q(0);
 //   Vector<Real, comp> qt = _q;
 //   qt *= (1 - grad_step);
 
 //   Loop::stridedLoop(
 //     [sigma, qt] CUDA_LAMBDA(VectorProxy<Real, comp>&& g,
 //                             VectorProxy<Real, comp>&& h) {
 //       g -= h;
 //       g *= sigma;
 //       g += qt;
 //     },
 //     *gap, *surfaceComp);
 // }
 
 template <UInt comp>
 void Condat::updateGap(Real sigma, Real grad_step, GridBase<Real>& q) {
   computeGradient<comp>();
 
   VectorProxy<Real, comp> _q(q(0));
   Vector<Real, comp> qt = _q;
   qt *= (1 - grad_step);
 
   Loop::loop(
       [sigma, qt] CUDA_LAMBDA(VectorProxy<Real, comp> g) {
         g *= sigma;
         g += qt;
       },
       range<VectorProxy<Real, comp>>(*gap));
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Condat::updateLagrange(GridBase<Real>& q, GridBase<Real>& p0) {
   *pressure_old *= -0.5;
   *pressure_old += *pressure;
   Vector<Real, comp> corr = computeMean<comp>(*pressure_old);
   corr *= 2;
   q += corr;
   q -= p0;
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/condat.hh b/src/solvers/condat.hh
index 27dd091..02c2d42 100644
--- a/src/solvers/condat.hh
+++ b/src/solvers/condat.hh
@@ -1,54 +1,55 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef CONDAT_HH
 #define CONDAT_HH
 /* -------------------------------------------------------------------------- */
 #include "kato.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class Condat : public Kato {
 public:
   /// Constructor
   Condat(Model& model, const GridBase<Real>& surface, Real tolerance, Real mu);
 
 public:
   /// Solve
   Real solve(GridBase<Real>& p0, Real grad_step);
 
   /// Template for solve function
   template <model_type type>
   Real solveTmpl(GridBase<Real>& p0, Real grad_step);
   /// Update gap
   template <UInt comp>
   void updateGap(Real sigma, Real grad_step, GridBase<Real>& q);
   /// Update Lagrange multiplier q
   template <UInt comp>
   void updateLagrange(GridBase<Real>& q, GridBase<Real>& p0);
 
 private:
   std::unique_ptr<GridBase<Real>> pressure_old = nullptr;
 };
 
 }  // namespace tamaas
 
 #endif  // CONDAT_HH
diff --git a/src/solvers/contact_solver.cpp b/src/solvers/contact_solver.cpp
index dd8892c..0df2b3d 100644
--- a/src/solvers/contact_solver.cpp
+++ b/src/solvers/contact_solver.cpp
@@ -1,67 +1,68 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "contact_solver.hh"
 #include "logger.hh"
 #include <iomanip>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 ContactSolver::ContactSolver(Model& model, const GridBase<Real>& surface,
                              Real tolerance)
     : model(model), tolerance(tolerance),
       surface_stddev(std::sqrt(surface.var())) {
 
   auto discretization = model.getBoundaryDiscretization();
   auto n_points = model.getTraction().getNbPoints();
 
   if (n_points != surface.dataSize())
     TAMAAS_EXCEPTION("Model size and surface size do not match!");
 
   this->surface.wrap(surface);
   _gap = allocateGrid<true, Real>(model.getType(), discretization);
   model.registerField("gap", _gap);
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactSolver::printState(UInt iter, Real cost_f, Real error) const {
   if (iter % dump_frequency)
     return;
   logIteration(iter, cost_f, error);
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactSolver::logIteration(UInt iter, Real cost_f, Real error) const {
   Logger().get(LogLevel::info)
       << std::setw(5) << iter << " " << std::setw(15) << std::scientific
       << cost_f << " " << std::setw(15) << error << std::endl
       << std::fixed;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactSolver::addFunctionalTerm(
     std::shared_ptr<functional::Functional> func) {
   functional.addFunctionalTerm(std::move(func));
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/contact_solver.hh b/src/solvers/contact_solver.hh
index db90235..627ffd7 100644
--- a/src/solvers/contact_solver.hh
+++ b/src/solvers/contact_solver.hh
@@ -1,87 +1,88 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef CONTACT_SOLVER_HH
 #define CONTACT_SOLVER_HH
 /* -------------------------------------------------------------------------- */
 #include "meta_functional.hh"
 #include "model.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class ContactSolver {
 public:
   /// Constructor
   ContactSolver(Model& model, const GridBase<Real>& surface, Real tolerance);
   /// Destructor
   virtual ~ContactSolver() = default;
 
 public:
   /// Print state of solve
   virtual void printState(UInt iter, Real cost_f, Real error) const;
   /// Log iteration info
   virtual void logIteration(UInt iter, Real cost_f, Real error) const;
   /// Get maximum number of iterations
   auto getMaxIterations() const { return max_iterations; }
   /// Set maximum number of iterations
   void setMaxIterations(UInt n) { max_iterations = n; }
   /// Get dump_frequency
   auto getDumpFrequency() const { return dump_frequency; }
   /// Set dump_frequency
   void setDumpFrequency(UInt n) { dump_frequency = n; }
   /// Add term to functional
   void addFunctionalTerm(std::shared_ptr<functional::Functional> func);
   /// Returns functional object
   const functional::Functional& getFunctional() const { return functional; }
 
   // Virtual functions
 public:
   /// Solve for a mean traction vector
   virtual Real solve(std::vector<Real> /*load*/) {
     TAMAAS_EXCEPTION("solve() not implemented");
   }
 
   /// Solve for normal pressure
   virtual Real solve(Real load) { return solve(std::vector<Real>{load}); }
 
   /// Accessor for tolerance
   TAMAAS_ACCESSOR(tolerance, Real, Tolerance);
 
 public:
   GridBase<Real>& getSurface() { return surface; }
   Model& getModel() { return model; }
 
 protected:
   Model& model;
   GridBase<Real> surface;
   std::shared_ptr<GridBase<Real>> _gap = nullptr;
   functional::MetaFunctional functional;
 
   Real tolerance;
   UInt max_iterations = 1000;
   Real surface_stddev;
   UInt dump_frequency = 100;
 };
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif  // CONTACT_SOLVER_HH
diff --git a/src/solvers/dfsane_solver.cpp b/src/solvers/dfsane_solver.cpp
index d2be218..8a273fc 100644
--- a/src/solvers/dfsane_solver.cpp
+++ b/src/solvers/dfsane_solver.cpp
@@ -1,163 +1,164 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "dfsane_solver.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 DFSANESolver::DFSANESolver(Residual& residual)
     : EPSolver(residual),
       search_direction(residual.getVector().dataSize(),
                        residual.getVector().getNbComponents()),
       previous_residual(residual.getVector().dataSize(),
                         residual.getVector().getNbComponents()),
       current_x(residual.getVector().dataSize(),
                 residual.getVector().getNbComponents()),
       delta_x(residual.getVector().dataSize(),
               residual.getVector().getNbComponents()),
       delta_residual(residual.getVector().dataSize(),
                      residual.getVector().getNbComponents()) {}
 
 void DFSANESolver::solve() {
   EPSolver::beforeSolve();
 
   auto& x_prev = *_x;
 
   UInt k = 0, nmax = 500;
   Real F_norm = 0;
   previous_merits.clear();
 
   _residual.computeResidual(x_prev);
   previous_residual = _residual.getVector();
 
   const auto F_norm0 = previous_residual.l2norm();
   eta = [F_norm0](UInt k) { return F_norm0 / ((1 + k) * (1 + k)); };
 
   const std::pair<Real, Real> sigma_extrema{1e-10, 1e10};
 
   Real sigma = 1;
   do {
     computeSearchDirection(sigma);
     lineSearch(eta(k));
 
     // No need for a solution update
     // it was done automatically in line search
 
     sigma = computeSpectralCoeff(sigma_extrema);
 
     x_prev = current_x;
     previous_residual = _residual.getVector();
     F_norm = previous_residual.l2norm();
 
     Logger().get(LogLevel::debug) << TAMAAS_DEBUG_MSG(k << ' ' << F_norm);
 
   } while (F_norm > getTolerance() and k++ < nmax);
 
   if (k >= nmax)
     TAMAAS_EXCEPTION("DF-SANE did not converge");
 
   Logger().get(LogLevel::info) << "DF-SANE: sucessful convergence (" << k
                                << " iterations, " << getTolerance() << ")\n";
   _residual.computeResidualDisplacement(*_x);
 }
 
 Real DFSANESolver::computeSpectralCoeff(const std::pair<Real, Real>& bounds) {
   delta_x = current_x;
   delta_x -= *_x;
 
   delta_residual = _residual.getVector();
   delta_residual -= previous_residual;
 
   auto trial = delta_x.dot(delta_x) / delta_x.dot(delta_residual);
 
   if (std::abs(trial) >= bounds.first and std::abs(trial) <= bounds.second)
     return trial;
 
   auto F = previous_residual.l2norm();
 
   // Rule from Cruz et al. (2006)
   if (F > 1)
     return 1;
   if (F < 1e-5)
     return 1e5;
   return 1 / F;
 }
 
 void DFSANESolver::computeSearchDirection(Real sigma) {
   _residual.computeResidual(*_x);
   search_direction = _residual.getVector();
   search_direction *= -sigma;
 }
 
 void DFSANESolver::lineSearch(Real eta_k) {
   const UInt M = 10;
   const Real gamma = 1e-4;
   Real alphap = 1, alpham = 1;
   const std::pair<Real, Real> tau_extrema{0.1, 0.5};
 
   // Merit function (nexp = 2)
   const auto f = [&](Real alpha, Real sign) {
     current_x = search_direction;
     current_x *= alpha * sign;
     current_x += *_x;
     _residual.computeResidual(current_x);
     return _residual.getVector().dot(_residual.getVector());
   };
 
   // Manage previous merits
   const auto fk = _residual.getVector().dot(_residual.getVector());
   previous_merits.push_front(fk);
   if (previous_merits.size() > M)
     previous_merits.pop_back();
 
   const auto fbar =
       *std::max_element(previous_merits.begin(), previous_merits.end());
 
   do {
     Real fp = f(alphap, +1);
     if (fp < fbar + eta_k - gamma * alphap * alphap * fk)
       return;
 
     Real fm = f(alpham, -1);
     if (fm < fbar + eta_k - gamma * alpham * alpham * fk)
       return;
 
     alphap = computeAlpha(alphap, fp, fk, tau_extrema);
     alpham = computeAlpha(alpham, fm, fk, tau_extrema);
 
     if (std::isnan(alphap) or std::isnan(alpham))
       TAMAAS_EXCEPTION("NaN error in line search");
   } while (true);
 }
 
 Real DFSANESolver::computeAlpha(Real alpha, Real f, Real fk,
                                 const std::pair<Real, Real>& bounds) {
   const auto alphat = alpha * alpha * fk / (f + (2 * alpha - 1) * fk);
 
   if (alphat < bounds.first * alpha)
     return bounds.first * alpha;
   if (alphat > bounds.second * alpha)
     return bounds.second * alpha;
   return alphat;
 }
 
 }  // namespace tamaas
diff --git a/src/solvers/dfsane_solver.hh b/src/solvers/dfsane_solver.hh
index 5bd8dc5..00dacfe 100644
--- a/src/solvers/dfsane_solver.hh
+++ b/src/solvers/dfsane_solver.hh
@@ -1,69 +1,70 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef DFSANE_SOLVER_HH
 #define DFSANE_SOLVER_HH
 /* -------------------------------------------------------------------------- */
 #include "ep_solver.hh"
 #include "grid_base.hh"
 #include "residual.hh"
 #include <deque>
 #include <functional>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /**
  @brief Derivative-free non-linear solver
 
  This algorithm is based on W. La Cruz, J. Martínez, and M. Raydan, “Spectral
  residual method without gradient information for solving large-scale nonlinear
  systems of equations,” Math. Comp., vol. 75, no. 255, pp. 1429–1448, 2006, doi:
  10.1090/S0025-5718-06-01840-0.
 
  The same algorithm is available in scipy.optimize, but this version is robustly
  parallel by default (i.e. does not depend on BLAS's parallelism and is
  future-proof for MPI parallelism).
 */
 class DFSANESolver : public EPSolver {
   // Public interface
 public:
   DFSANESolver(Residual& residual);
   void solve() override;
 
   // Algorithm functions
 protected:
   Real computeSpectralCoeff(const std::pair<Real, Real>& bounds);
   void computeSearchDirection(Real sigma);
   void lineSearch(Real eta_k);
   static Real computeAlpha(Real alpha, Real f, Real fk,
                            const std::pair<Real, Real>& bounds);
 
 protected:
   GridBase<Real> search_direction, previous_residual, current_x, delta_x,
       delta_residual;
   std::deque<Real> previous_merits;
   std::function<Real(UInt)> eta;
 };
 
 }  // namespace tamaas
 #endif
diff --git a/src/solvers/ep_solver.cpp b/src/solvers/ep_solver.cpp
index b41c3f3..0cee981 100644
--- a/src/solvers/ep_solver.cpp
+++ b/src/solvers/ep_solver.cpp
@@ -1,47 +1,48 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "ep_solver.hh"
 #include "model_type.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 EPSolver::EPSolver(Residual& residual) : _residual(residual) {
   auto& model = residual.getModel();
   auto dim = model.getDiscretization().size();
   _x = allocateGrid<false, Real>(model.getType(), model.getDiscretization(),
                                  dim * (dim / 2 + 1));  // voigt
   model.registerField("strain_increment", _x);
 }
 
 /* -------------------------------------------------------------------------- */
 void EPSolver::beforeSolve() {
   abs_tol.step();
 }
 
 /* -------------------------------------------------------------------------- */
 void EPSolver::updateState() {
   _residual.updateState(getStrainIncrement());
   abs_tol.reset();
 }
 
 }  // namespace tamaas
diff --git a/src/solvers/ep_solver.hh b/src/solvers/ep_solver.hh
index d909710..d2d7de3 100644
--- a/src/solvers/ep_solver.hh
+++ b/src/solvers/ep_solver.hh
@@ -1,71 +1,72 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef EP_SOLVER_HH
 #define EP_SOLVER_HH
 /* -------------------------------------------------------------------------- */
 #include "grid_base.hh"
 #include "residual.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 struct ToleranceManager {
   Real start_tol, end_tol, rate, tolerance;
 
   ToleranceManager(Real start, Real end, Real rate)
       : start_tol(start / rate), end_tol(end), rate(rate),
         tolerance(start_tol) {}
 
   void step() { tolerance = std::max(end_tol, rate * tolerance); }
   void reset() { tolerance = start_tol; }
 };
 
 class EPSolver {
 public:
   /// Constructor
   EPSolver(Residual& residual);
   /// Destructor
   virtual ~EPSolver() = default;
 
   // Main methods
 public:
   virtual void solve() = 0;
   virtual void updateState();
   virtual void beforeSolve();
 
   // Accessors
 public:
   GridBase<Real>& getStrainIncrement() { return *_x; }
   Residual& getResidual() { return _residual; }
   Real getTolerance() const { return abs_tol.tolerance; }
   void setTolerance(Real tol) { abs_tol = ToleranceManager{tol, tol, 1}; }
   void setToleranceManager(ToleranceManager manager) { abs_tol = manager; }
 
 protected:
   std::shared_ptr<GridBase<Real>> _x;
   Residual& _residual;
   ToleranceManager abs_tol{1e-9, 1e-9, 1};
 };
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 #endif
diff --git a/src/solvers/epic.cpp b/src/solvers/epic.cpp
index a8d86f2..9c526fa 100644
--- a/src/solvers/epic.cpp
+++ b/src/solvers/epic.cpp
@@ -1,148 +1,149 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "epic.hh"
 #include "logger.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 EPICSolver::EPICSolver(ContactSolver& csolver, EPSolver& epsolver,
                        Real tolerance, Real relaxation)
     : csolver(csolver), epsolver(epsolver), tolerance(tolerance),
       relaxation(relaxation) {
   auto& model = csolver.getModel();
   surface.wrap(csolver.getSurface());
   pressure.resize(model.getTraction().getNbPoints());
 
   /// \cond DO_NOT_DOCUMENT
 #define SET_VIEWS(_, __, type)                                                 \
   case type: {                                                                 \
     setViews<type>();                                                          \
     break;                                                                     \
   }
 
   switch (model.getType()) {
     BOOST_PP_SEQ_FOR_EACH(SET_VIEWS, ~, TAMAAS_MODEL_TYPES);
   }
 
 #undef SET_VIEWS
   /// \endcond
 }
 
 /* -------------------------------------------------------------------------- */
 void EPICSolver::solve(const std::vector<Real>& load) {
   UInt n = 0, nmax = 1000;
   Real error = 0.;
   const GridBase<Real> initial_surface(surface);
   Real normalizing_factor = std::sqrt(initial_surface.var());
   GridBase<Real> previous_residual(*residual_disp);
   GridBase<Real> relaxation_direction(*residual_disp);
   previous_residual = 0;
   pressure = *pressure_inc;  // set previous pressure to current model pressure
 
   do {
     fixedPoint(relaxation_direction, previous_residual, initial_surface, load);
     relaxation_direction -= previous_residual;
     relaxation_direction *= relaxation;
 
     error = computeError(*residual_disp, previous_residual, normalizing_factor);
 
     previous_residual += relaxation_direction;
 
     Logger().get(LogLevel::info) << "[EPIC] error = " << std::scientific
                                  << error << std::fixed << std::endl;
   } while (error > tolerance && n++ < nmax);
 
   // computing full pressure
   pressure += *pressure_inc;
   // setting the model pressure to full converged pressure
   *pressure_inc = pressure;
   // updating plastic state
   epsolver.updateState();
 }
 
 /* -------------------------------------------------------------------------- */
 void EPICSolver::acceleratedSolve(const std::vector<Real>& load) {
   UInt n = 0, nmax = 1000;
   Real error = 0.;
   const GridBase<Real> initial_surface(surface);
   Real normalizing_factor = std::sqrt(initial_surface.var());
   GridBase<Real> doubleg(*residual_disp), dg(*residual_disp),
       d2x(*residual_disp), x(*residual_disp), x_prev(*residual_disp);
 
   do {
     // First compute g(x) and g(g(x))
     fixedPoint(dg, x, initial_surface, load);
     fixedPoint(doubleg, dg, initial_surface, load);
     // dg contains g(x): compute delta x
     d2x = dg;
     d2x -= x;
     // compute delta g(x)
     dg *= -1;
     dg += doubleg;
     // now we have delta g(x) and delta x, compute delta^2 x
     d2x *= -1;
     d2x += dg;
     // Apply Irons & Truck iteration
     auto f = dg.dot(d2x) / d2x.dot(d2x);
     dg *= -f;
     x = doubleg;
     x += dg;
 
     error = computeError(x, x_prev, normalizing_factor);
     x_prev = x;
 
     Logger().get(LogLevel::info) << "[EPIC] error = " << std::scientific
                                  << error << std::fixed << std::endl;
   } while (error > tolerance && n++ < nmax);
 
   // computing full pressure
   pressure += *pressure_inc;
   // setting the model pressure to full converged pressure
   *pressure_inc = pressure;
   // updating plastic state
   epsolver.updateState();
 }
 
 /* -------------------------------------------------------------------------- */
 void EPICSolver::fixedPoint(GridBase<Real>& result, const GridBase<Real>& x,
                             const GridBase<Real>& initial_surface,
                             std::vector<Real> load) {
   surface = initial_surface;
   surface -= x;
 
   csolver.solve(std::move(load));
   *pressure_inc -= pressure;
   epsolver.solve();
   result = *residual_disp;
 }
 
 /* -------------------------------------------------------------------------- */
 Real EPICSolver::computeError(const GridBase<Real>& current,
                               const GridBase<Real>& prev, Real factor) const {
   GridBase<Real> error(current);
   error -= prev;
   return std::sqrt(error.dot(error)) / factor;
 }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
diff --git a/src/solvers/epic.hh b/src/solvers/epic.hh
index f038395..befdb8a 100644
--- a/src/solvers/epic.hh
+++ b/src/solvers/epic.hh
@@ -1,83 +1,84 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef EPIC_HH
 #define EPIC_HH
 /* -------------------------------------------------------------------------- */
 #include "contact_solver.hh"
 #include "ep_solver.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 class EPICSolver {
 public:
   /// Constructor
   EPICSolver(ContactSolver& csolver, EPSolver& epsolver, Real tolerance = 1e-10,
              Real relaxation = 0.3);
 
   void solve(const std::vector<Real>& load);
   void acceleratedSolve(const std::vector<Real>& load);
   Real computeError(const GridBase<Real>& current, const GridBase<Real>& prev,
                     Real factor) const;
 
   void fixedPoint(GridBase<Real>& result, const GridBase<Real>& x,
                   const GridBase<Real>& initial_surface,
                   std::vector<Real> load);
 
   template <model_type type>
   void setViews();
 
 protected:
   GridBase<Real> surface;                         ///< corrected surface
   GridBase<Real> pressure;                        ///< current pressure
   std::unique_ptr<GridBase<Real>> residual_disp;  ///< plastic residual disp
   std::unique_ptr<GridBase<Real>> pressure_inc;   ///< pressure increment
 
   ContactSolver& csolver;
   EPSolver& epsolver;
 
   Real tolerance, relaxation;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Template impl. */
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 void EPICSolver::setViews() {
   constexpr UInt dim = model_type_traits<type>::dimension;
   constexpr UInt bdim = model_type_traits<type>::boundary_dimension;
   constexpr UInt comp = model_type_traits<type>::components;
 
   pressure_inc =
       std::unique_ptr<GridBase<Real>>{new GridView<Grid, Real, bdim, bdim>(
           csolver.getModel().getTraction(), {}, comp - 1)};
   residual_disp =
       std::unique_ptr<GridBase<Real>>{new GridView<Grid, Real, dim, bdim>(
           csolver.getModel().getDisplacement(),
           model_type_traits<type>::indices, comp - 1)};
 }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 #endif  // EPIC_HH
diff --git a/src/solvers/kato.cpp b/src/solvers/kato.cpp
index d482765..495c066 100644
--- a/src/solvers/kato.cpp
+++ b/src/solvers/kato.cpp
@@ -1,507 +1,508 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "kato.hh"
 #include "elastic_functional.hh"
 #include "logger.hh"
 #include "loop.hh"
 #include <iomanip>
 #include <iostream>
 #include <iterator>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 Kato::Kato(Model& model, const GridBase<Real>& surface, Real tolerance, Real mu)
     : ContactSolver(model, surface, tolerance), engine(model.getBEEngine()),
       mu(mu) {
   if (model.getType() != model_type::surface_1d &&
       model.getType() != model_type::surface_2d) {
     TAMAAS_EXCEPTION("Model type is not compatible with Kato solver");
   }
 
   gap = this->_gap.get();  // locally allocated
   pressure = &model.getTraction();
   N = pressure->getNbPoints();
 
   if (model.getType() == model_type::surface_1d) {
     initSurfaceWithComponents<model_type::surface_1d>();
   } else {
     initSurfaceWithComponents<model_type::surface_2d>();
   }
 
   engine.registerNeumann();
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Kato::solve(GridBase<Real>& p0, UInt proj_iter) {
   if (p0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean pressure does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveTmpl<model_type::surface_1d>(p0, proj_iter);
     break;
   case model_type::surface_2d:
     cost = solveTmpl<model_type::surface_2d>(p0, proj_iter);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real Kato::solveTmpl(GridBase<Real>& p0, UInt proj_iter) {
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0;
   UInt n = 0;
 
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   pressure->uniformSetComponents(p0);
 
   do {
     computeGradient<comp>();
     *pressure -= *gap;
 
     enforcePressureConstraints<comp>(p0, proj_iter);
     cost = computeCost();
     printState(n, cost, cost);
   } while (cost > this->tolerance && n++ < this->max_iterations);
 
   computeFinalGap<comp>();
 
   return cost;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Kato::solveRelaxed(GridBase<Real>& g0) {
   if (g0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean gap does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveRelaxedTmpl<model_type::surface_1d>(g0);
     break;
   case model_type::surface_2d:
     cost = solveRelaxedTmpl<model_type::surface_2d>(g0);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real Kato::solveRelaxedTmpl(GridBase<Real>& g0) {
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0;
   UInt n = 0;
 
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   *pressure = 0;
 
   do {
     engine.solveNeumann(*pressure, *gap);
     addUniform<comp>(*gap, g0);
     *gap -= *surfaceComp;
     *pressure -= *gap;
 
     enforcePressureCoulomb<comp>();
     cost = computeCost();
     printState(n, cost, cost);
   } while (cost > this->tolerance && n++ < this->max_iterations);
 
   computeFinalGap<comp>();
 
   return cost;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Kato::solveRegularized(GridBase<Real>& p0, Real r) {
   if (p0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean pressure does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveRegularizedTmpl<model_type::surface_1d>(p0, r);
     break;
   case model_type::surface_2d:
     cost = solveRegularizedTmpl<model_type::surface_2d>(p0, r);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real Kato::solveRegularizedTmpl(GridBase<Real>& p0, Real r) {
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0;
   UInt n = 0;
 
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   pressure->uniformSetComponents(p0);
 
   do {
     // enforcePressureMean<comp>(p0);
     engine.solveNeumann(*pressure, *gap);
     *gap -= *surfaceComp;
 
     // Impose zero tangential displacement in non-sliding zone
     const auto mu = this->mu;
     UInt count_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> p) -> UInt {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_N = p(comp - 1);
 
           if (0.99 * mu * p_N > p_T.l2norm())  // non-sliding contact
             return 1;
           return 0;
         },
         range<VectorProxy<Real, comp>>(*pressure));
 
     Vector<Real, comp> g_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> g,
                          VectorProxy<Real, comp> p) -> Vector<Real, comp> {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_N = p(comp - 1);
 
           if (0.99 * mu * p_N > p_T.l2norm())  // non-sliding contact
             return g;                          // to compute mean of g_T
           return 0;
         },
         range<VectorProxy<Real, comp>>(*gap),
         range<VectorProxy<Real, comp>>(*pressure));
 
     g_static /= count_static != 0 ? count_static : 1;
     g_static(comp - 1) = 0;
 
     Loop::loop(
         [mu, r, g_static] CUDA_LAMBDA(VectorProxy<Real, comp> p,
                                       VectorProxy<Real, comp> g) {
           // Add frictional term to gradient of functional
           g -= g_static;
           // Vector<Real, comp> _g = g; // copy
           VectorProxy<Real, comp - 1> g_T(g(0));
           VectorProxy<Real, 1> g_N(g(comp - 1));
           Real g_T_norm = g_T.l2norm();
           // g_N += mu * regularize(g_T_norm, r) * g_T_norm;
           g_N += mu * g_T_norm;
 
           // Update pressure with gradient
           // _g *= 0.1;
           p -= g;
 
           // Truncate negative normal pressure
           VectorProxy<Real, comp - 1> p_T(p(0));
           VectorProxy<Real, 1> p_N(p(comp - 1));
           if (p_N(0) < 0)
             p_N = 0;
 
           // Set tangential pressure
           p_T = g_T;
           if (g_T_norm != 0)
             p_T *= -mu * p_N(0) * Kato::regularize(g_T_norm, r) / g_T_norm;
         },
         range<VectorProxy<Real, comp>>(*pressure),
         range<VectorProxy<Real, comp>>(*gap));
 
     // enforcePressureMean<comp>(p0);
     // enforcePressureCoulomb<comp>();
     enforcePressureConstraints<comp>(p0, 50);
     cost = computeCost();
     printState(n, cost, cost);
   } while (std::abs(cost) > this->tolerance && n++ < this->max_iterations);
 
   computeFinalGap<comp>();
 
   return cost;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 void Kato::initSurfaceWithComponents() {
   constexpr UInt comp = model_type_traits<type>::components;
   surfaceComp = allocateGrid<true, Real>(type, model.getDiscretization(), comp);
   *surfaceComp = 0;
 
   Loop::loop([] CUDA_LAMBDA(Real & s,
                             VectorProxy<Real, comp> sc) { sc(comp - 1) = s; },
              surface, range<VectorProxy<Real, comp>>(*surfaceComp));
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::enforcePressureMean(GridBase<Real>& p0) {
   Vector<Real, comp> corr = computeMean<comp>(*pressure);
   VectorProxy<Real, comp> _p0(p0(0));
   corr -= _p0;
   *pressure -= corr;
 }
 
 /* -------------------------------------------------------------------------- */
 
 // template <UInt comp>
 // void Kato::enforcePressureCoulomb() {
 //   Loop::stridedLoop(
 //     [this] CUDA_LAMBDA(VectorProxy<Real, comp>&& p) {
 //       VectorProxy<Real, comp - 1> p_T(p(0));
 //       Real p_N = p(comp - 1);
 //       Real p_T_sqrd= p_T.l2squared();
 
 //       // Projection normale au cône de friction
 //       bool cond1 = (p_N >= 0 && p_T_sqrd <= mu * mu * p_N * p_N);
 //       bool cond2 = (p_N <= 0 && p_T_sqrd <= p_N * p_N / mu / mu);
 
 //       if (cond2) {
 //         p_T = 0;
 //         p(comp - 1) = 0;
 //       } else if (!cond1) {
 //         Real p_T_norm = std::sqrt(p_T_sqrd);
 //         Real k = (p_N + mu * p_T_norm) / (1 + mu * mu);
 //         p_T *= k * mu / p_T_norm;
 //         p(comp - 1) = k;
 //       }
 //     },
 //     *pressure);
 // }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::enforcePressureTresca() {
   Loop::loop(
       [this] CUDA_LAMBDA(VectorProxy<Real, comp> p) {
         VectorProxy<Real, comp - 1> p_T(p(0));
         Real p_N = p(comp - 1);
         Real p_T_norm = p_T.l2norm();
 
         if (p_N < 0) {
           p_T = 0;
           p(comp - 1) = 0;
         } else if (p_T_norm > mu) {  // TODO: replace name of variable mu
           p_T *= mu / p_T_norm;
           // p(comp - 1) += p_T_norm - mu;
         }
       },
       range<VectorProxy<Real, comp>>(*pressure));
 }
 
 template void Kato::enforcePressureTresca<2>();
 template void Kato::enforcePressureTresca<3>();
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Compute mean of the field taking each component separately.
  */
 // template <UInt comp>
 // Vector<Real, comp> Kato::computeMean(GridBase<Real>& field) {
 //   Vector<Real, comp> mean = Loop::stridedReduce<operation::plus>(
 //     [] CUDA_LAMBDA(VectorProxy<Real, comp>&& f) -> Vector<Real, comp> {
 //       return f;
 //     },
 //     field);
 
 //   mean /= N;
 //   return mean;
 // }
 
 /* -------------------------------------------------------------------------- */
 
 // template <UInt comp>
 // void Kato::addUniform(GridBase<Real>& field, GridBase<Real>& vec) {
 //   VectorProxy<Real, comp> _vec(vec(0));
 //   field += _vec;
 // }
 
 /* -------------------------------------------------------------------------- */
 
 Real Kato::computeCost(bool use_tresca) {
   UInt N = pressure->getNbPoints();
   Grid<Real, 1> lambda({N}, 1);
   Grid<Real, 1> eta({N}, 1);
   Grid<Real, 1> p_N({N}, 1);
   Grid<Real, 1> p_C({N}, 1);
 
   switch (model.getType()) {
   case model_type::surface_1d:
     if (!use_tresca) {
       computeValuesForCost<model_type::surface_1d>(lambda, eta, p_N, p_C);
     } else {
       computeValuesForCostTresca<model_type::surface_1d>(lambda, eta, p_N, p_C);
     }
     break;
 
   case model_type::surface_2d:
     if (!use_tresca) {
       computeValuesForCost<model_type::surface_2d>(lambda, eta, p_N, p_C);
     } else {
       computeValuesForCostTresca<model_type::surface_2d>(lambda, eta, p_N, p_C);
     }
     break;
 
   default:
     break;
   }
 
   return p_N.dot(lambda) + p_C.dot(eta);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 void Kato::computeValuesForCost(GridBase<Real>& lambda, GridBase<Real>& eta,
                                 GridBase<Real>& p_N, GridBase<Real>& p_C) {
   constexpr UInt comp = model_type_traits<type>::components;
 
   Real g_N_min = Loop::reduce<operation::min>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> g) { return g(comp - 1); },
       range<VectorProxy<Real, comp>>(*gap));
 
   Loop::loop(
       [this, g_N_min] CUDA_LAMBDA(VectorProxy<Real, comp> p,
                                   VectorProxy<Real, comp> g, Real & lambda_,
                                   Real & eta_, Real & p_N_, Real & p_C_) {
         VectorProxy<Real, comp - 1> g_T(g(0));
         Real g_N = g(comp - 1);
         Real g_T_norm = g_T.l2norm();
         lambda_ = g_N - g_N_min;
         eta_ = g_T_norm;
 
         VectorProxy<Real, comp - 1> p_T(p(0));
         Real p_N = p(comp - 1);
         Real p_T_norm = p_T.l2norm();
         p_N_ = p_N;
         p_C_ = (p_N > 0) ? mu * p_N - p_T_norm : 0;
       },
       range<VectorProxy<Real, comp>>(*pressure),
       range<VectorProxy<Real, comp>>(*gap), lambda, eta, p_N, p_C);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <model_type type>
 void Kato::computeValuesForCostTresca(GridBase<Real>& lambda,
                                       GridBase<Real>& eta, GridBase<Real>& p_N,
                                       GridBase<Real>& p_C) {
   constexpr UInt comp = model_type_traits<type>::components;
 
   Real g_N_min = Loop::reduce<operation::min>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> g) { return g(comp - 1); },
       range<VectorProxy<Real, comp>>(*gap));
 
   Real p_C_min = Loop::reduce<operation::min>(
       [this] CUDA_LAMBDA(VectorProxy<Real, comp> p) {
         VectorProxy<Real, comp - 1> p_T(p(0));
         Real p_T_norm = p_T.l2norm();
         return mu - p_T_norm;
       },
       range<VectorProxy<Real, comp>>(*pressure));
 
   Loop::loop(
       [this, g_N_min, p_C_min] CUDA_LAMBDA(
           VectorProxy<Real, comp> p, VectorProxy<Real, comp> g, Real & lambda_,
           Real & eta_, Real & p_N_, Real & p_C_) {
         VectorProxy<Real, comp - 1> g_T(g(0));
         Real g_N = g(comp - 1);
         Real g_T_norm = g_T.l2norm();
         lambda_ = g_N - g_N_min;
         eta_ = g_T_norm;
 
         VectorProxy<Real, comp - 1> p_T(p(0));
         Real p_N = p(comp - 1);
         Real p_T_norm = p_T.l2norm();
         p_N_ = p_N;
         p_C_ = (p_N > 0) ? mu - p_T_norm - p_C_min : 0;
       },
       range<VectorProxy<Real, comp>>(*pressure),
       range<VectorProxy<Real, comp>>(*gap), lambda, eta, p_N, p_C);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::computeFinalGap() {
   engine.solveNeumann(*pressure, *gap);
   *gap -= *surfaceComp;
 
   Real g_N_min = Loop::reduce<operation::min>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> g) { return g(comp - 1); },
       range<VectorProxy<Real, comp>>(*gap));
 
   Grid<Real, 1> g_shift({comp}, 1);
   g_shift = 0;
   g_shift(comp - 1) = -g_N_min;
 
   *gap += *surfaceComp;
   addUniform<comp>(*gap, g_shift);
 
   model.getDisplacement() = *gap;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Kato::regularize(Real x, Real r) {
   Real xr = x / r;
   return xr / (1 + std::abs(xr));
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/kato.hh b/src/solvers/kato.hh
index daefa8d..f79c413 100644
--- a/src/solvers/kato.hh
+++ b/src/solvers/kato.hh
@@ -1,322 +1,323 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef KATO_HH
 #define KATO_HH
 /* -------------------------------------------------------------------------- */
 #include "contact_solver.hh"
 #include "meta_functional.hh"
 #include "model_type.hh"
 #include "static_types.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class Kato : public ContactSolver {
 public:
   /// Constructor
   Kato(Model& model, const GridBase<Real>& surface, Real tolerance, Real mu);
 
 public:
   /// Solve
   Real solve(GridBase<Real>& p0, UInt proj_iter);
   /// Solve relaxed problem
   Real solveRelaxed(GridBase<Real>& g0);
   /// Solve regularized problem
   Real solveRegularized(GridBase<Real>& p0, Real r);
   /// Compute cost function
   Real computeCost(bool use_tresca = false);
 
 public:
   /// Template for solve function
   template <model_type type>
   Real solveTmpl(GridBase<Real>& p0, UInt proj_iter);
   /// Template for solveRelaxed function
   template <model_type type>
   Real solveRelaxedTmpl(GridBase<Real>& g0);
   /// Template for solveRegularized function
   template <model_type type>
   Real solveRegularizedTmpl(GridBase<Real>& p0, Real r);
 
 public:
   /// Creates surfaceComp form surface
   template <model_type type>
   void initSurfaceWithComponents();
   /// Compute gradient of functional
   template <UInt comp>
   void computeGradient(bool use_tresca = false);
   /// Project pressure on friction cone
   template <UInt comp>
   void enforcePressureConstraints(GridBase<Real>& p0, UInt proj_iter);
   /// Project on C
   template <UInt comp>
   void enforcePressureMean(GridBase<Real>& p0);
   /// Project on D
   template <UInt comp>
   void enforcePressureCoulomb();
   /// Project on D (Tresca)
   template <UInt comp>
   void enforcePressureTresca();
   /// Comupte mean value of field
   template <UInt comp>
   Vector<Real, comp> computeMean(GridBase<Real>& field);
   /// Add vector to each point of field
   template <UInt comp>
   void addUniform(GridBase<Real>& field, GridBase<Real>& vec);
   /// Regularization function with factor r (0 -> unregugularized)
   static __device__ __host__ Real regularize(Real x, Real r);
 
   /// Compute grids of dual and primal variables
   template <model_type type>
   void computeValuesForCost(GridBase<Real>& lambda, GridBase<Real>& eta,
                             GridBase<Real>& p_N, GridBase<Real>& p_C);
   /// Compute dual and primal variables with Tresca friction
   template <model_type type>
   void computeValuesForCostTresca(GridBase<Real>& lambda, GridBase<Real>& eta,
                                   GridBase<Real>& p_N, GridBase<Real>& p_C);
 
   /// Compute total displacement
   template <UInt comp>
   void computeFinalGap();
 
 protected:
   BEEngine& engine;
   GridBase<Real>* gap = nullptr;
   GridBase<Real>* pressure = nullptr;
   std::unique_ptr<GridBase<Real>> surfaceComp = nullptr;
   Real mu = 0;
   UInt N = 0;  // number of points
 };
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::computeGradient(bool use_tresca) {
   engine.solveNeumann(*pressure, *gap);
   *gap -= *surfaceComp;
 
   // Impose zero tangential displacement in non-sliding zone
   UInt count_static = 0;
   Vector<Real, comp> g_static;
   using pvector = VectorProxy<Real, comp>;
   const auto mu = this->mu;
 
   if (!use_tresca) {  // with Coulomb friction
 
     count_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> p) -> UInt {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_T_norm = p_T.l2norm();
           Real p_N = p(comp - 1);
 
           return (0.99 * mu * p_N > p_T_norm) ? 1 : 0;
         },
         range<pvector>(*pressure));
 
     g_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> g,
                          VectorProxy<Real, comp> p) -> Vector<Real, comp> {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_T_norm = p_T.l2norm();
           Real p_N = p(comp - 1);
 
           if (0.99 * mu * p_N > p_T_norm)
             return g;
           return 0;
         },
         range<pvector>(*gap), range<pvector>(*pressure));
 
   } else {  // with Tresca friction
 
     count_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> p) -> UInt {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_T_norm = p_T.l2norm();
           Real p_N = p(comp - 1);
 
           return (0.99 * mu > p_T_norm && p_N > 0) ? 1 : 0;
         },
         range<pvector>(*pressure));
 
     g_static = Loop::reduce<operation::plus>(
         [mu] CUDA_LAMBDA(VectorProxy<Real, comp> g,
                          VectorProxy<Real, comp> p) -> Vector<Real, comp> {
           VectorProxy<Real, comp - 1> p_T(p(0));
           Real p_N = p(comp - 1);
           Real p_T_norm = p_T.l2norm();
 
           if (0.99 * mu > p_T_norm && p_N > 0)
             return g;
           return 0;
         },
         range<pvector>(*gap), range<pvector>(*pressure));
   }
 
   if (count_static != 0) {
     g_static /= count_static;
     // g_static(comp - 1) = 0;
   } else {  // if no sticking zone, mean computed on sliding zone
 
     count_static = Loop::reduce<operation::plus>(
         [] CUDA_LAMBDA(VectorProxy<Real, comp> p) -> UInt {
           return (p(comp - 1) > 0) ? 1 : 0;
         },
         range<pvector>(*pressure));
 
     Real g_N_static = Loop::reduce<operation::plus>(
         [] CUDA_LAMBDA(VectorProxy<Real, comp> g, VectorProxy<Real, comp> p)
             -> Real { return (p(comp - 1) > 0) ? g(comp - 1) : 0; },
         range<pvector>(*gap), range<pvector>(*pressure));
 
     g_static(comp - 1) = g_N_static / count_static;
   }
 
   // Add frictionnal term to functional
   if (!use_tresca) {  // with Coulomb friction
 
     Loop::loop(
         [mu, g_static] CUDA_LAMBDA(VectorProxy<Real, comp> g) {
           g -= g_static;
           VectorProxy<Real, comp - 1> g_T(g(0));
           Real g_T_norm = g_T.l2norm();
           g(comp - 1) += mu * g_T_norm;  // Frictionnal work
         },
         range<pvector>(*gap));
 
   } else {  // with Tresca friction
 
     *gap -= g_static;
 
     // Loop::stridedLoop(
     //   [this, g_static] CUDA_LAMBDA(VectorProxy<Real, comp>&& g,
     //                                VectorProxy<Real, comp>&& p) {
     //     g -= g_static;
     //     VectorProxy<Real, comp - 1> g_T = g(0);
     //     Real g_T_norm = g_T.l2norm();
     //     Real p_N = p(comp - 1);
     //     if (p_N > 0)
     //       g(comp - 1) += mu/p_N * g_T_norm; // Frictionnal work
     //   },
     //   *gap, *pressure);
   }
 
   // Loop::stridedLoop(
   // [this] CUDA_LAMBDA(VectorProxy<Real, comp>&& g, VectorProxy<Real, comp>&&
   // p) {
   //   VectorProxy<Real, comp - 1> g_T = g(0);
   //   Real g_T_norm = g_T.l2norm();
   //   VectorProxy<Real, 1> g_N = g(comp - 1);
 
   //   VectorProxy<Real, comp - 1> p_T = p(0);
   //   Real p_T_norm = p_T.l2norm();
   //   VectorProxy<Real, 1> p_N = p(comp - 1);
 
   //   if (p_T_norm != 0) {
   //     g_T = p_T;
   //     g_T *= -g_T_norm / p_T_norm;
   //   }
   //   g_N += mu * g_T_norm; // Frictionnal work
   // },
   // *gap, *pressure);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Projects \f$\vec{p}\f$ on \f$\mathcal{C}\f$ and \f$\mathcal{D}\f$.
  */
 // template <UInt comp>
 // void Kato::enforcePressureConstraints(GridBase<Real>& p0, UInt proj_iter) {
 //   for (UInt i = 0; i < proj_iter; i++) {
 //     enforcePressureMean<comp>(p0);
 //     enforcePressureCoulomb<comp>();
 //   }
 // }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Projects \f$\vec{p}\f$ on \f$\mathcal{C}\f$ and \f$\mathcal{D}\f$.
  */
 template <UInt comp>
 void Kato::enforcePressureConstraints(GridBase<Real>& p0, UInt proj_iter) {
   for (UInt i = 0; i < proj_iter; i++) {
     enforcePressureMean<comp>(p0);
     enforcePressureCoulomb<comp>();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::enforcePressureCoulomb() {
   const auto mu = this->mu;
   Loop::loop(
       [mu] CUDA_LAMBDA(VectorProxy<Real, comp> p) {
         VectorProxy<Real, comp - 1> p_T(p(0));
         Real p_N = p(comp - 1);
         Real p_T_sqrd = p_T.l2squared();
 
         // Projection normale au cône de friction
         bool cond1 = (p_N >= 0 && p_T_sqrd <= mu * mu * p_N * p_N);
         bool cond2 = (p_N <= 0 && p_T_sqrd <= p_N * p_N / mu / mu);
 
         if (cond2) {
           p_T = 0;
           p(comp - 1) = 0;
         } else if (!cond1) {
           Real p_T_norm = std::sqrt(p_T_sqrd);
           Real k = (p_N + mu * p_T_norm) / (1 + mu * mu);
           p_T *= k * mu / p_T_norm;
           p(comp - 1) = k;
         }
       },
       range<VectorProxy<Real, comp>>(*pressure));
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Compute mean of the field taking each component separately.
  */
 template <UInt comp>
 Vector<Real, comp> Kato::computeMean(GridBase<Real>& field) {
   Vector<Real, comp> mean = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> f) -> Vector<Real, comp> {
         return f;
       },
       range<VectorProxy<Real, comp>>(field));
 
   mean /= N;
   return mean;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void Kato::addUniform(GridBase<Real>& field, GridBase<Real>& vec) {
   VectorProxy<Real, comp> _vec(vec(0));
   field += _vec;
 }
 
 }  // namespace tamaas
 
 #endif  // KATO_HH
diff --git a/src/solvers/kato_saturated.cpp b/src/solvers/kato_saturated.cpp
index fd3fef9..283c3bf 100644
--- a/src/solvers/kato_saturated.cpp
+++ b/src/solvers/kato_saturated.cpp
@@ -1,236 +1,237 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "kato_saturated.hh"
 #include "logger.hh"
 #include <iomanip>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 KatoSaturated::KatoSaturated(Model& model, const GridBase<Real>& surface,
                              Real tolerance, Real pmax)
     : PolonskyKeerRey(model, surface, tolerance, PolonskyKeerRey::pressure,
                       PolonskyKeerRey::pressure),
       pmax(pmax) {
   auto residual_disp = allocateGrid<true, Real>(
       model.getType(), model.getBoundaryDiscretization());
   model.registerField("KatoSaturated::residual_displacement",
                       std::move(residual_disp));
 }
 
 /* -------------------------------------------------------------------------- */
 Real KatoSaturated::solve(std::vector<Real> load) {
   GridBase<Real> initial_surface = surface;
   GridBase<Real>& residual_disp = model["KatoSaturated::residual_displacement"];
   residual_disp = 0;
 
   auto negative = [this](const GridBase<Real>& f) {
     return f.min() < -std::abs(this->tolerance);
   };
 
   UInt n = 0;
 
   do {
     surface = initial_surface;
     surface -= residual_disp;
 
     PolonskyKeerRey::solve(load);
 
     // Update the rough surface
     Loop::loop([] CUDA_LAMBDA(Real & h_pl, Real g) { h_pl -= g * (g < 0); },
                residual_disp, *this->dual);
   } while (negative(*this->dual) and n++ < this->max_iterations);
 
   surface = initial_surface;
   *this->displacement_view += residual_disp;
 
   return Real(n >= this->max_iterations);
 }
 
 /* -------------------------------------------------------------------------- */
 Real KatoSaturated::meanOnUnsaturated(const GridBase<Real>& /*field*/) const {
   return 0;
 }
 
 Real KatoSaturated::computeSquaredNorm(const GridBase<Real>& /*field*/) const {
   return 1.;
 }
 
 void KatoSaturated::updateSearchDirection(Real /*factor*/) {
   *this->search_direction = *this->dual;
 }
 
 Real KatoSaturated::computeCriticalStep(Real /*target*/) {
   // integral_op->apply(*search_direction, *projected_search_direction);
   // Real num = search_direction->dot(*search_direction);
   // Real denum = projected_search_direction->dot(*search_direction);
   // return 0.1 * num / denum;
   return 1;
 }
 
 bool KatoSaturated::updatePrimal(Real step) {
   UInt na_num = Loop::reduce<operation::plus>(
       [step] CUDA_LAMBDA(Real & p, const Real& /*q*/, const Real& t) -> UInt {
         p -= step * t;  // Updating primal
         return 0;
         // if (p < 0)
         //   p = 0;                // Truncating neg values
         // if (p == 0 && q < 0) {  // If non-admissible state
         //   p -= step * q;
         //   return 1;
         // } else
         //   return 0;
       },
       *primal, *dual, *search_direction);
 
   return na_num == 0;
 }
 
 /* -------------------------------------------------------------------------- */
 Real KatoSaturated::computeError() {
   // We shift the gap by the minimum on unsaturated area
   const auto pmax = this->pmax;
   Real shift = Loop::reduce<operation::min>(
       [pmax] CUDA_LAMBDA(Real p, Real d) {
         return (p < pmax) ? d : std::numeric_limits<Real>::max();
       },
       *primal, *dual);
   *dual -= shift;
 
   Real norm = 1;
 
   // Ignore points that are saturated
   Real error = Loop::reduce<operation::plus>(
       [pmax] CUDA_LAMBDA(Real p, Real d) { return (p < pmax) ? p * d : 0; },
       *primal, *dual);
 
   if (std::isnan(error))
     TAMAAS_EXCEPTION("Encountered NaN in complementarity error: this may be "
                      "caused by a contact area of a single node.");
 
   if (variable_type == pressure)
     norm = std::abs(primal->sum() * this->surface_stddev);
   else
     norm = std::abs(dual->sum() * this->surface_stddev);
 
   norm *= primal->getGlobalNbPoints();
   return std::abs(error) / norm;
 }
 
 /* -------------------------------------------------------------------------- */
 void KatoSaturated::enforceMeanValue(Real mean) {
   // We want to cancel the difference between saturated alpha + t and the
   // applied pressure
   const auto pmax = this->pmax;
   *primal -= primal->mean();
   auto f = [&](Real scale) {
     Real sum = Loop::reduce<operation::plus>(
         [pmax, scale] CUDA_LAMBDA(Real t) -> Real {
           t += scale;
 
           if (t > pmax)
             return pmax;
           if (t < 0)
             return 0;
           return t;
         },
         *this->primal);
     sum /= this->primal->getGlobalNbPoints();
     return sum - mean;
   };
 
   if (pmax < mean)
     TAMAAS_EXCEPTION("Cannot find equilibrium");
 
   // Dichotomy + Secant Newton on f
 
   // Initial points
   Real x_n_2 = -primal->max(), x_n_1 = -primal->min(), x_n = 0.;
   Real f_n_2 = 0., f_n_1 = 0., f_n = 0.;
 
   // Find a not-to-large search interval
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("Searching equilibrium interval");
   while (std::signbit(f(x_n_1)) == std::signbit(f(x_n_2))) {
     x_n_1 *= 10;
     x_n_2 *= 10;
   }
 
   Logger().get(LogLevel::debug) << TAMAAS_DEBUG_MSG(
       "Reducing interval [abs(x1/x2) = " << std::abs(x_n_1 / x_n_2) << ']');
   UInt n_dic = 10;
   f_n_1 = f(x_n_1);
   for (UInt i = 0; i < n_dic; ++i) {
     x_n = 0.5 * (x_n_1 + x_n_2);
     f_n = f(x_n);
     if (std::signbit(f_n) == std::signbit(f_n_1)) {
       x_n_1 = x_n;
       f_n_1 = f_n;
     } else
       x_n_2 = x_n;
   }
 
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("Starting Newton secant [abs(x1/x2) = "
                           << std::abs(x_n_1 / x_n_2) << ']');
 
   // Secant loop
   do {
     f_n_2 = f(x_n_2);
     f_n_1 = f(x_n_1);
     if (f_n_1 == f_n_2)
       break;  // Avoid nans
     x_n = x_n_1 - f_n_1 * (x_n_1 - x_n_2) / (f_n_1 - f_n_2);
     f_n = f(x_n);
     x_n_2 = x_n_1;
     x_n_1 = x_n;
   } while (std::abs(f_n / mean) > 1e-14);
 
   // Pressure update
   Loop::loop(
       [pmax, x_n] CUDA_LAMBDA(Real & t) {
         t += x_n;
         if (t > pmax)
           t = pmax;
         else if (t < 0)
           t = 0.;
       },
       *this->primal);
 }
 
 /* -------------------------------------------------------------------------- */
 void KatoSaturated::enforceAdmissibleState() {
   /// Make dual admissible
   const auto pmax = this->pmax;
   Real shift = Loop::reduce<operation::min>(
       [pmax] CUDA_LAMBDA(Real p, Real d) {
         return (p < pmax) ? d : std::numeric_limits<Real>::max();
       },
       *primal, *dual);
   *dual -= shift;
 
   *displacement_view = *dual;
   *displacement_view += this->surface;
 }
 
 }  // namespace tamaas
diff --git a/src/solvers/kato_saturated.hh b/src/solvers/kato_saturated.hh
index 45f14cc..347466c 100644
--- a/src/solvers/kato_saturated.hh
+++ b/src/solvers/kato_saturated.hh
@@ -1,73 +1,74 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef KATO_SATURATED_HH
 #define KATO_SATURATED_HH
 /* -------------------------------------------------------------------------- */
 #include "polonsky_keer_rey.hh"
 #include <limits>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 /// Polonsky-Keer algorithm with saturation of the pressure
 class KatoSaturated : public PolonskyKeerRey {
 public:
   /// Constructor
   KatoSaturated(Model& model, const GridBase<Real>& surface, Real tolerance,
                 Real pmax);
   ~KatoSaturated() override = default;
 
 public:
   /// Solve
   Real solve(std::vector<Real> load) override;
   /// Mean on unsaturated constraint zone
   Real meanOnUnsaturated(const GridBase<Real>& field) const override;
   /// Compute squared norm
   Real computeSquaredNorm(const GridBase<Real>& field) const override;
   /// Update search direction
   void updateSearchDirection(Real factor) override;
   /// Compute critical step
   Real computeCriticalStep(Real target = 0) override;
   /// Update primal and check non-admissible state
   bool updatePrimal(Real step) override;
   /// Compute error/stopping criterion
   Real computeError() override;
   /// Enfore mean value constraint
   void enforceMeanValue(Real mean) override;
   /// Enforce contact constraints on final state
   void enforceAdmissibleState() override;
   /// Access to pmax
   Real getPMax() const { return pmax; }
   /// Set pax
   void setPMax(Real p) {
     if (p <= 0)
       pmax = std::numeric_limits<Real>::max();
     else
       pmax = p;
   }
 
 protected:
   Real pmax = std::numeric_limits<Real>::max();  ///< saturation pressure
 };
 
 }  // namespace tamaas
 #endif  // KATO_SATURATED_HH
diff --git a/src/solvers/polonsky_keer_rey.cpp b/src/solvers/polonsky_keer_rey.cpp
index ec215dc..87840a2 100644
--- a/src/solvers/polonsky_keer_rey.cpp
+++ b/src/solvers/polonsky_keer_rey.cpp
@@ -1,302 +1,303 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "polonsky_keer_rey.hh"
 #include "elastic_functional.hh"
 #include "logger.hh"
 #include "loop.hh"
 #include "model_type.hh"
 #include <boost/preprocessor/seq.hpp>
 #include <iomanip>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 PolonskyKeerRey::PolonskyKeerRey(Model& model, const GridBase<Real>& surface,
                                  Real tolerance, type variable_type,
                                  type constraint_type)
     : ContactSolver(model, surface, tolerance), variable_type(variable_type),
       constraint_type(constraint_type) {
 
 #define SET_VIEWS(_, __, type)                                                 \
   case type: {                                                                 \
     setViews<type>();                                                          \
     break;                                                                     \
   }
 
   switch (model.getType()) {
     BOOST_PP_SEQ_FOR_EACH(SET_VIEWS, ~, TAMAAS_MODEL_TYPES);
   }
 
 #undef SET_VIEWS
 
   search_direction = allocateGrid<true, Real>(
       operation_type, model.getBoundaryDiscretization());
 
   projected_search_direction = allocateGrid<true, Real>(
       operation_type, model.getBoundaryDiscretization());
 
   switch (variable_type) {
   case gap: {
     model.getBEEngine().registerDirichlet();
     primal = gap_view.get();
     dual = pressure_view.get();
     this->functional.addFunctionalTerm(
         std::make_shared<functional::ElasticFunctionalGap>(*integral_op,
                                                            this->surface));
     break;
   }
   case pressure: {
     model.getBEEngine().registerNeumann();
     primal = pressure_view.get();
     dual = gap_view.get();
     this->functional.addFunctionalTerm(
         std::make_shared<functional::ElasticFunctionalPressure>(*integral_op,
                                                                 this->surface));
     break;
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real PolonskyKeerRey::solve(std::vector<Real> target_v) {
   // Update in case of a surface change between solves
   this->surface_stddev = std::sqrt(this->surface.var());
 
   // Printing column headers
   Logger().get(LogLevel::info) << std::setw(5) << "Iter"
                                << " " << std::setw(15) << "Cost_f"
                                << " " << std::setw(15) << "Error" << '\n'
                                << std::fixed;
 
   const Real target = target_v.back();
   // Setting uniform value if constraint
   if (constraint_type == variable_type && std::abs(primal->sum()) <= 0)
     *primal = target;
   else if (constraint_type == variable_type)
     *primal *= target / primal->mean();
   else if (constraint_type != variable_type)
     *primal = this->surface_stddev;
 
   // Algorithm variables
   Real Gold = 1, error = 0;
   UInt n = 0;
   bool delta = false;
   *search_direction = 0;
 
   do {
     // Computing functional gradient
     functional.computeGradF(*primal, *dual);
 
     const Real dbar = meanOnUnsaturated(*dual);
     // Enforcing dual constraint via gradient
     if (constraint_type != variable_type) {
       *dual += 2 * target + dbar;
     } else {
       // Centering dual on primal > 0
       *dual -= dbar;
     }
 
     // Computing gradient norm
     const Real G = computeSquaredNorm(*dual);
 
     // Updating search direction (conjugate gradient)
     updateSearchDirection(delta * G / Gold);
     Gold = G;
 
     // Computing critical step
     const Real tau = computeCriticalStep(target);
 
     // Update primal variable
     delta = updatePrimal(tau);
 
     // We should scale to constraint
     if (constraint_type == variable_type)
       enforceMeanValue(target);
 
     error = computeError();
     const Real cost_f = functional.computeF(*primal, *dual);
     printState(n, cost_f, error);
   } while (error > this->tolerance and n++ < this->max_iterations);
 
   // Final update of dual variable
   functional.computeGradF(*primal, *dual);
 
   // Log final iteration
   logIteration(n, functional.computeF(*primal, *dual), error);
 
   enforceAdmissibleState();
 
   return error;
 }
 
 /* -------------------------------------------------------------------------- */
 void PolonskyKeerRey::enforceAdmissibleState() {
   /// Make dual admissible
   const Real dual_min = dual->min();
   *dual -= dual_min;
 
   // Primal is pressure: need to make sure gap is positive
   if (variable_type == pressure) {
     *displacement_view = *dual;
     *displacement_view += this->surface;
   }
   // Primal is gap: need to make sure dual is positive (pressure + adhesion)
   else {
     *displacement_view = *primal;
     *displacement_view += this->surface;
     integral_op->apply(*displacement_view, *pressure_view);
     *pressure_view -= dual_min;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Computes \f$ \frac{1}{\mathrm{card}(\{p > 0\})} \sum_{\{p > 0\}}{f_i} \f$
  */
 Real PolonskyKeerRey::meanOnUnsaturated(const GridBase<Real>& field) const {
   // Sum on unsaturated
   const Real sum = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(Real & p, const Real& f) { return (p > 0) ? f : 0; },
       *primal, field);
   // Number of unsaturated points
   const UInt n_unsat = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(Real & p) -> UInt { return (p > 0); }, *primal);
 
   return sum / n_unsat;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Computes \f$ \sum_{\{p > 0\}}{f_i^2} \f$
  */
 Real PolonskyKeerRey::computeSquaredNorm(const GridBase<Real>& field) const {
   return Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(Real & p, const Real& f) { return (p > 0) ? f * f : 0; },
       *primal, field);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Computes \f$ \tau = \frac{ \sum_{\{p > 0\}}{q_i't_i} }{ \sum_{\{p > 0\}}{r_i'
  * t_i} } \f$
  */
 Real PolonskyKeerRey::computeCriticalStep(Real target) {
   integral_op->apply(*search_direction, *projected_search_direction);
 
   const Real rbar = meanOnUnsaturated(*projected_search_direction);
   if (constraint_type == variable_type)
     *projected_search_direction -= rbar;
   else {
     *projected_search_direction += 2 * target + rbar;
   }
 
   const Real num = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(const Real& p, const Real& q, const Real& t) {
         return (p > 0) ? q * t : 0;
       },
       *primal, *dual, *search_direction);
   const Real denum = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(const Real& p, const Real& r, const Real& t) {
         return (p > 0) ? r * t : 0;
       },
       *primal, *projected_search_direction, *search_direction);
 
   return num / denum;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Update steps:
  * 1. \f$\mathbf{p} = \mathbf{p} - \tau \mathbf{t} \f$
  * 2. Truncate all \f$p\f$ negative
  * 3. For all points in \f$I_\mathrm{na} = \{p = 0 \land q < 0 \}\f$ do \f$p_i =
  * p_i - \tau q_i\f$
  */
 bool PolonskyKeerRey::updatePrimal(Real step) {
   const UInt na_num = Loop::reduce<operation::plus>(
       [step] CUDA_LAMBDA(Real & p, const Real& q, const Real& t) -> UInt {
         p -= step * t;  // Updating primal
         if (p < 0)
           p = 0;                // Truncating neg values
         if (p == 0 && q < 0) {  // If non-admissible state
           p -= step * q;
           return 1;
         }
         return 0;
       },
       *primal, *dual, *search_direction);
 
   return na_num == 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Error is based on \f$ \sum{p_i q_i} \f$
  */
 Real PolonskyKeerRey::computeError() {
   /// Making sure dual respects constraint
   *dual -= dual->min();
 
   /// Complementarity error
   const Real error = primal->dot(*dual);
 
   if (std::isnan(error))
     TAMAAS_EXCEPTION("Encountered NaN in complementarity error: this may be "
                      "caused by a contact area of a single node.");
 
   const Real norm = [this]() {
     if (variable_type == pressure)
       return std::abs(primal->sum() * this->surface_stddev);
     return std::abs(dual->sum() * this->surface_stddev);
   }();
 
   return std::abs(error) / (norm * primal->getGlobalNbPoints());
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Do \f$\mathbf{t} = \mathbf{q}' + \delta \frac{R}{R_\mathrm{old}}\mathbf{t}
  * \f$
  */
 void PolonskyKeerRey::updateSearchDirection(Real factor) {
   Loop::loop(
       [factor] CUDA_LAMBDA(Real & p, Real & q, Real & t) {
         t = (p > 0) ? q + factor * t : 0;
       },
       *primal, *dual, *search_direction);
 }
 
 /* -------------------------------------------------------------------------- */
 void PolonskyKeerRey::enforceMeanValue(Real mean) {
   *primal *= mean / primal->mean();
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/polonsky_keer_rey.hh b/src/solvers/polonsky_keer_rey.hh
index caf7c70..b6f69e6 100644
--- a/src/solvers/polonsky_keer_rey.hh
+++ b/src/solvers/polonsky_keer_rey.hh
@@ -1,130 +1,131 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef POLONSKY_KEER_REY_HH
 #define POLONSKY_KEER_REY_HH
 /* -------------------------------------------------------------------------- */
 #include "contact_solver.hh"
 #include "grid_view.hh"
 #include "meta_functional.hh"
 #include "westergaard.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class PolonskyKeerRey : public ContactSolver {
 public:
   /// Types of algorithm (primal/dual) or constraint
   enum type { gap, pressure };
 
 public:
   /// Constructor
   PolonskyKeerRey(Model& model, const GridBase<Real>& surface, Real tolerance,
                   type variable_type, type constraint_type);
   ~PolonskyKeerRey() override = default;
 
 public:
   /// \cond DO_NOT_DOCUMENT
   using ContactSolver::solve;
   ///\endcond
 
   /// Solve
   Real solve(std::vector<Real> target) override;
   /// Mean on unsaturated constraint zone
   virtual Real meanOnUnsaturated(const GridBase<Real>& field) const;
   /// Compute squared norm
   virtual Real computeSquaredNorm(const GridBase<Real>& field) const;
   /// Update search direction
   virtual void updateSearchDirection(Real factor);
   /// Compute critical step
   virtual Real computeCriticalStep(Real target = 0);
   /// Update primal and check non-admissible state
   virtual bool updatePrimal(Real step);
   /// Compute error/stopping criterion
   virtual Real computeError();
   /// Enforce contact constraints on final state
   virtual void enforceAdmissibleState();
   /// Enfore mean value constraint
   virtual void enforceMeanValue(Real mean);
 
 private:
   /// Set correct views on normal traction and gap
   template <model_type type>
   void setViews();
 
 protected:
   type variable_type, constraint_type;
   model_type operation_type;
   GridBase<Real>* primal = nullptr;  ///< non-owning pointer for primal varaible
   GridBase<Real>* dual = nullptr;    ///< non-owning pointer for dual variable
 
   /// CG search direction
   std::unique_ptr<GridBase<Real>> search_direction = nullptr;
   /// Projected CG search direction
   std::unique_ptr<GridBase<Real>> projected_search_direction = nullptr;
   /// View on normal pressure, gap, displacement
   std::unique_ptr<GridBase<Real>> pressure_view, gap_view,
       displacement_view = nullptr;
 
   /// Integral operator for gradient computation
   IntegralOperator* integral_op = nullptr;
 };
 
 /* -------------------------------------------------------------------------- */
 template <model_type mtype>
 void PolonskyKeerRey::setViews() {
   constexpr UInt dim = model_type_traits<mtype>::dimension;
   constexpr UInt bdim = model_type_traits<mtype>::boundary_dimension;
   constexpr UInt comp = model_type_traits<mtype>::components;
 
   pressure_view = std::unique_ptr<GridBase<Real>>{
       new GridView<Grid, Real, bdim, bdim>(model.getTraction(), {}, comp - 1)};
   gap_view = std::unique_ptr<GridBase<Real>>{
       new GridView<Grid, Real, bdim, bdim>(*this->_gap, {}, comp - 1)};
   displacement_view =
       std::unique_ptr<GridBase<Real>>{new GridView<Grid, Real, dim, bdim>(
           model.getDisplacement(), model_type_traits<mtype>::indices,
           comp - 1)};
 
 #define WESTERGAARD(type, kind, desc)                                          \
   this->model.registerIntegralOperator<                                        \
       Westergaard<model_type::type, IntegralOperator::kind>>(desc)
 
   // I noz is fugly - TODO factory?
   if (bdim == 1) {
     operation_type = model_type::basic_1d;
     if (variable_type == gap)
       integral_op = WESTERGAARD(basic_1d, dirichlet, "westergaard_dirichlet");
     else
       integral_op = WESTERGAARD(basic_1d, neumann, "westergaard_neumann");
   } else if (bdim == 2) {
     operation_type = model_type::basic_2d;
     if (variable_type == gap)
       integral_op = WESTERGAARD(basic_2d, dirichlet, "westergaard_dirichlet");
     else
       integral_op = WESTERGAARD(basic_2d, neumann, "westergaard_neumann");
   }
 
 #undef WESTERGAARD
 }
 
 }  // namespace tamaas
 
 #endif  // POLONSKY_KEER_REY_HH
diff --git a/src/solvers/polonsky_keer_tan.cpp b/src/solvers/polonsky_keer_tan.cpp
index da1b8fd..5a642bc 100644
--- a/src/solvers/polonsky_keer_tan.cpp
+++ b/src/solvers/polonsky_keer_tan.cpp
@@ -1,333 +1,334 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "polonsky_keer_tan.hh"
 #include <iomanip>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 PolonskyKeerTan::PolonskyKeerTan(Model& model, const GridBase<Real>& surface,
                                  Real tolerance, Real mu)
     : Kato(model, surface, tolerance, mu) {
   search_direction =
       allocateGrid<true, Real>(model.getType(), model.getDiscretization(),
                                model.getTraction().getNbComponents());
 
   search_direction_backup =
       allocateGrid<true, Real>(model.getType(), model.getDiscretization(),
                                model.getTraction().getNbComponents());
 
   projected_search_direction =
       allocateGrid<true, Real>(model.getType(), model.getDiscretization(),
                                model.getTraction().getNbComponents());
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real PolonskyKeerTan::solve(GridBase<Real>& p0) {
   if (p0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean pressure does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveTmpl<model_type::surface_1d>(p0);
     break;
   case model_type::surface_2d:
     cost = solveTmpl<model_type::surface_2d>(p0);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real PolonskyKeerTan::solveTresca(GridBase<Real>& p0) {
   if (p0.getNbPoints() != pressure->getNbComponents()) {
     TAMAAS_EXCEPTION(
         "Target mean pressure does not have the right number of components");
   }
 
   Real cost = 0;
 
   switch (model.getType()) {
   case model_type::surface_1d:
     cost = solveTmpl<model_type::surface_1d>(p0, true);
     break;
   case model_type::surface_2d:
     cost = solveTmpl<model_type::surface_2d>(p0, true);
     break;
   default:
     break;
   }
 
   return cost;
 }
 
 template <model_type type>
 Real PolonskyKeerTan::solveTmpl(GridBase<Real>& p0, bool use_tresca) {
   // Printing column headers
   std::cout << std::setw(5) << "Iter"
             << " " << std::setw(15) << "Cost_f"
             << " " << std::setw(15) << "Error" << '\n'
             << std::fixed;
 
   constexpr UInt comp = model_type_traits<type>::components;
   Real cost = 0.0;
   Real error = 0.0;
   UInt n = 0;
 
   pressure->uniformSetComponents(p0);
   Real R_old = 1.0;
   *search_direction = 0.0;
 
   do {
     // Enforce external condition (should be at the end)
     enforcePressureMean<comp>(p0);
 
     // Compute functional gradient
     computeGradient<comp>(use_tresca);
 
     // Compute search direction
     Real R = computeSquaredNorm(*gap);
     *search_direction *= R / R_old;
     *search_direction += *gap;
     R_old = R;
 
     // Compute step size
     Real tau = computeStepSize<comp>(false);
 
     // Update pressure
     *search_direction *= tau;
     *pressure -= *search_direction;
     *search_direction *= model.getSystemSize()[0] / model.getYoungModulus();
     // *search_direction *= 1/tau; // this line should *theoreticaly* replace
     // the one above
 
     // Enforce constraints
     if (!use_tresca) {
       enforcePressureCoulomb<comp>();
     } else {
       enforcePressureTresca<comp>();
     }
 
     cost = computeCost(use_tresca);
     error = cost / pressure->getNbPoints() / model.getSystemSize()[0] /
             model.getYoungModulus();
     printState(n, cost, error);
   } while (error > this->tolerance && n++ < this->max_iterations);
 
   computeFinalGap<comp>();
 
   return error;
 }
 
 // Original algorithm
 // template <model_type type>
 // Real PolonskyKeerTan::solveTmpl(GridBase<Real>& p0) {
 //   // Printing column headers
 //   std::cout << std::setw(5) << "Iter"
 //             << " " << std::setw(15) << "Cost_f"
 //             << " " << std::setw(15) << "Error" << '\n'
 //             << std::fixed;
 
 //   constexpr UInt comp = model_type_traits<type>::components;
 //   Real cost = 0.0;
 //   UInt n = 0;
 
 //   pressure->uniformSetComponents(p0);
 //   Real R_old = 1.0;
 //   Real delta = 0.0;
 //   *search_direction = 0.0;
 
 //   do {
 //     // Enforce external condition (should be at the end)
 //     enforcePressureMean<comp>(p0);
 
 //     // Compute functional gradient
 //     computeGradient<comp>();
 //     Vector<Real, comp> gap_mean = computeMean<comp>(*gap, true);
 //     for (UInt i = 0; i < comp - 1; i++) gap_mean(i) = 0;
 //     *gap -= gap_mean;
 
 //     // Compute search direction
 //     Real R = computeSquaredNorm(*gap);
 //     *search_direction *= delta * R / R_old;
 //     *search_direction += *gap;
 //     R_old = R;
 //     truncateSearchDirection<comp>(true);
 
 //     // Compute step size
 //     Real tau = computeStepSize<comp>(true);
 
 //     // Update pressure
 //     *search_direction *= tau;
 //     *pressure -= *search_direction;
 
 //     // Enforce constraints
 //     enforcePressureCoulomb<comp>();
 
 //     // Empty set of inadmissible gaps
 //     UInt na_count = Loop::stridedReduce<operation::plus>(
 //     [tau] CUDA_LAMBDA(VectorProxy<Real, comp>&& p,
 //                       VectorProxy<Real, comp>&& g) {
 //       if (p(comp - 1) == 0.0 && g(comp - 1) < 0.0) {
 //         Vector<Real, comp> _g = g;
 //         _g *= tau;
 //         p -= _g;
 //         return 1;
 //       } else {
 //         return 0;
 //       }
 //     },
 //     *pressure, *gap);
 
 //     delta = (na_count > 0) ? 0.0 : 1.0;
 
 //     // Enforce external condition
 //     // enforcePressureMean<comp>(p0);
 
 //     cost = computeCost();
 //     printState(n, cost, cost);
 //   } while (cost > this->tolerance && n++ < this->max_iterations);
 
 //   computeFinalGap<comp>();
 
 //   return cost;
 // }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void PolonskyKeerTan::enforcePressureMean(GridBase<Real>& p0) {
   Vector<Real, comp> pressure_mean = computeMean<comp>(*pressure, false);
   // *pressure -= pressure_mean;
   // addUniform<comp>(*pressure, p0);
 
   // for (UInt i = 0; i < comp; i++)
   //   if (pressure_mean(i) == 0) pressure_mean(i) = 1.0;
   // *pressure /= pressure_mean;
   // VectorProxy<Real, comp> _p0(p0(0));
   // *pressure *= _p0;
 
   VectorProxy<Real, comp> _p0(p0(0));
   Loop::loop(
       [pressure_mean, _p0] CUDA_LAMBDA(VectorProxy<Real, comp> p) {
         for (UInt i = 0; i < comp - 1; i++)
           p(i) += _p0(i) - pressure_mean(i);
         p(comp - 1) *= _p0(comp - 1) / pressure_mean(comp - 1);
       },
       range<VectorProxy<Real, comp>>(*pressure));
 
   // Loop::stridedLoop(
   //   [pressure_mean, p0] CUDA_LAMBDA(VectorProxy<Real, comp>&& p) {
   //     for (UInt i = 0; i < comp - 1; i++)
   //       p(i) *= p0(i) / (pressure_mean(i) != 0 ? pressure_mean(i) : 1);
   //     p(comp - 1) += p0(comp - 1) - pressure_mean(comp - 1);
   //   },
   //   *pressure);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 Vector<Real, comp> PolonskyKeerTan::computeMean(GridBase<Real>& field,
                                                 bool on_c) {
 
   UInt count = Loop::reduce<operation::plus>(
       [on_c] CUDA_LAMBDA(VectorProxy<Real, comp> p) -> UInt {
         return ((!on_c) || p(comp - 1) > 0.0) ? 1 : 0;
       },
       range<VectorProxy<Real, comp>>(*pressure));
 
   Vector<Real, comp> mean = Loop::reduce<operation::plus>(
       [on_c] CUDA_LAMBDA(VectorProxy<Real, comp> f,
                          VectorProxy<Real, comp> p) -> Vector<Real, comp> {
         if ((!on_c) || p(comp - 1) > 0.0)
           return f;
         return 0;
       },
       range<VectorProxy<Real, comp>>(field),
       range<VectorProxy<Real, comp>>(*pressure));
 
   mean /= count;
   return mean;
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real PolonskyKeerTan::computeSquaredNorm(GridBase<Real>& field) {
   return Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(Real & f) { return f * f; }, field);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 void PolonskyKeerTan::truncateSearchDirection(bool on_c) {
   if (!on_c)
     return;
   Loop::loop(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> t, VectorProxy<Real, comp> p) {
         if (p(comp - 1) == 0.0)
           t = 0.0;
       },
       range<VectorProxy<Real, comp>>(*search_direction),
       range<VectorProxy<Real, comp>>(*pressure));
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt comp>
 Real PolonskyKeerTan::computeStepSize(bool on_c) {
   engine.solveNeumann(*search_direction, *projected_search_direction);
   Vector<Real, comp> r_mean =
       computeMean<comp>(*projected_search_direction, on_c);
   *projected_search_direction -= r_mean;
 
   Real num = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> q, VectorProxy<Real, comp> t) {
         return q.dot(t);
       },
       range<VectorProxy<Real, comp>>(*gap),
       range<VectorProxy<Real, comp>>(*search_direction));
 
   Real denum = Loop::reduce<operation::plus>(
       [] CUDA_LAMBDA(VectorProxy<Real, comp> r, VectorProxy<Real, comp> t) {
         return r.dot(t);
       },
       range<VectorProxy<Real, comp>>(*projected_search_direction),
       range<VectorProxy<Real, comp>>(*search_direction));
 
   // if (denum == 0) denum = 1.0;
   return num / denum;
 }
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
diff --git a/src/solvers/polonsky_keer_tan.hh b/src/solvers/polonsky_keer_tan.hh
index d7d0e8b..5845392 100644
--- a/src/solvers/polonsky_keer_tan.hh
+++ b/src/solvers/polonsky_keer_tan.hh
@@ -1,67 +1,68 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef POLONSKY_KEER_TAN_HH
 #define POLONSKY_KEER_TAN_HH
 /* -------------------------------------------------------------------------- */
 #include "kato.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 class PolonskyKeerTan : public Kato {
 public:
   /// Constructor
   PolonskyKeerTan(Model& model, const GridBase<Real>& surface, Real tolerance,
                   Real mu);
 
 public:
   /// Solve with Coulomb friction
   Real solve(GridBase<Real>& p0);
   /// Solve with Tresca friction
   Real solveTresca(GridBase<Real>& p0);
 
   /// Template for solve function
   template <model_type type>
   Real solveTmpl(GridBase<Real>& p0, bool use_tresca = false);
   /// Enforce pressure mean
   template <UInt comp>
   void enforcePressureMean(GridBase<Real>& p0);
   /// Compute mean of field (only on I_c)
   template <UInt comp>
   Vector<Real, comp> computeMean(GridBase<Real>& field, bool on_c);
   /// Compute squared norm
   Real computeSquaredNorm(GridBase<Real>& field);
   /// Restrict search direction on I_c
   template <UInt comp>
   void truncateSearchDirection(bool on_c);
   /// Compute optimal step size (only on I_c)
   template <UInt comp>
   Real computeStepSize(bool on_c);
 
 private:
   std::unique_ptr<GridBase<Real>> search_direction = nullptr;
   std::unique_ptr<GridBase<Real>> search_direction_backup = nullptr;
   std::unique_ptr<GridBase<Real>> projected_search_direction = nullptr;
 };
 
 }  // namespace tamaas
 
 #endif  // POLONSKY_KEER_TAN_HH
diff --git a/src/surface/filter.hh b/src/surface/filter.hh
index 1fcd1e4..f98fd95 100644
--- a/src/surface/filter.hh
+++ b/src/surface/filter.hh
@@ -1,64 +1,65 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef FILTER_H
 #define FILTER_H
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "grid.hh"
 #include "grid_hermitian.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 template <UInt dim>
 class Filter {
 public:
   /// Default constructor
   Filter() = default;
   /// Destructor
   virtual ~Filter() = default;
 
 public:
   /// Compute Filter coefficients
   virtual void
   computeFilter(GridHermitian<Real, dim>& filter_coefficients) const = 0;
 
 protected:
   /// Compute filter coefficients using lambda
   template <typename T>
   void computeFilter(T&& f, GridHermitian<Real, dim>& filter) const;
 };
 
 template <UInt dim>
 template <typename T>
 void Filter<dim>::computeFilter(T&& f, GridHermitian<Real, dim>& filter) const {
   auto wavevectors =
       FFTEngine::template computeFrequencies<Real, dim, true>(filter.sizes());
 
   Loop::loop(std::forward<T>(f), filter,
              range<VectorProxy<Real, dim>>(wavevectors));
 }
 
 }  // namespace tamaas
 
 #endif  // FILTER_H
diff --git a/src/surface/isopowerlaw.cpp b/src/surface/isopowerlaw.cpp
index 8a41532..de29524 100644
--- a/src/surface/isopowerlaw.cpp
+++ b/src/surface/isopowerlaw.cpp
@@ -1,101 +1,102 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "isopowerlaw.hh"
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 template <UInt dim>
 void Isopowerlaw<dim>::computeFilter(
     GridHermitian<Real, dim>& filter_coefficients) const {
   Filter<dim>::computeFilter(
       [this] CUDA_LAMBDA(Complex & coeff, VectorProxy<Real, dim> q) {
         coeff = (*this)(q);
       },
       filter_coefficients);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Real Isopowerlaw<dim>::rmsHeights() const {
   return std::sqrt(moments()[0]);
 }
 
 /* -------------------------------------------------------------------------- */
 /// \cond DO_NOT_DOCUMENT
 /*
  * Analytical moments, cf. Yastrebov et al. (2015)
  * "From infinitesimal to full contact between rough surfaces: Evolution
  * of the contact area", appendix A
  */
 template <>
 std::vector<Real> Isopowerlaw<2>::moments() const {
   std::map<UInt, Real> T;
   T[0] = 2 * M_PI;
   T[2] = M_PI;
   T[4] = (3 * M_PI) / 4;
   Real q1 = static_cast<Real>(this->q1);  // shadowing this->q1
   Real xi = q0 / q1;
   Real zeta = q2 / q1;
   Real A = std::pow(q1, 2 * (hurst + 1));
 
   std::vector<Real> moments;
   moments.reserve(3);
   for (UInt q : {0, 2, 4}) {
     Real m = A * T[q] * std::pow(q1, q - 2 * hurst) *
              ((1 - std::pow(xi, q + 2)) / (q + 2) +
               (std::pow(zeta, q - 2 * hurst) - 1) / (q - 2 * hurst));
     moments.push_back(m);
   }
 
   return moments;
 }
 
 template <>
 std::vector<Real> Isopowerlaw<1>::moments() const {
   TAMAAS_EXCEPTION("Moments have not been implemented for 1D surfaces");
 }
 /// \endcond
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Real Isopowerlaw<dim>::alpha() const {
   const auto m = moments();
   return m[0] * m[2] / (m[1] * m[1]);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Real Isopowerlaw<dim>::rmsSlopes() const {
   // 2 pi because moments are computed with k instead of q
   // and slopes should be computed with q
   return 2 * M_PI * std::sqrt(2 * moments()[1]);
 }
 
 template class Isopowerlaw<1>;
 template class Isopowerlaw<2>;
 
 }  // namespace tamaas
diff --git a/src/surface/isopowerlaw.hh b/src/surface/isopowerlaw.hh
index 3481d40..5028fb5 100644
--- a/src/surface/isopowerlaw.hh
+++ b/src/surface/isopowerlaw.hh
@@ -1,93 +1,94 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef ISOPOWERLAW_H
 #define ISOPOWERLAW_H
 /* -------------------------------------------------------------------------- */
 #include "filter.hh"
 #include "grid_hermitian.hh"
 #include "static_types.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Class representing an isotropic power law spectrum
 template <UInt dim>
 class Isopowerlaw : public Filter<dim> {
 public:
   /// Compute filter coefficients
   void
   computeFilter(GridHermitian<Real, dim>& filter_coefficients) const override;
 
   /// Compute a point of the PSD
   CUDA_LAMBDA inline Real operator()(const VectorProxy<Real, dim>& q_vec) const;
 
   /// Analytical rms of heights
   Real rmsHeights() const;
 
   /// Analytical moments
   std::vector<Real> moments() const;
 
   /// Analytical Nayak's parameter
   Real alpha() const;
 
   /// Analytical RMS slopes
   Real rmsSlopes() const;
 
 public:
   TAMAAS_ACCESSOR(q0, UInt, Q0);
   TAMAAS_ACCESSOR(q1, UInt, Q1);
   TAMAAS_ACCESSOR(q2, UInt, Q2);
   TAMAAS_ACCESSOR(hurst, Real, Hurst);
 
 protected:
   UInt q0, q1, q2;
   Real hurst;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline implementations                                                     */
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 CUDA_LAMBDA inline Real Isopowerlaw<dim>::
 operator()(const VectorProxy<Real, dim>& q_vec) const {
   const Real C = 1.;
   const Real q = q_vec.l2norm();
 
   Real val;
 
   if (q < q0)
     val = 0;
   else if (q > q2)
     val = 0;
   else if (q < q1)
     val = C;
   else
     val = C * std::pow((q / q1), -(2. * hurst + dim));
 
   return std::sqrt(val);
 }
 
 }  // namespace tamaas
 
 #endif  // ISOPOWERLAW_H
diff --git a/src/surface/regularized_powerlaw.cpp b/src/surface/regularized_powerlaw.cpp
index ea146c1..92eafab 100644
--- a/src/surface/regularized_powerlaw.cpp
+++ b/src/surface/regularized_powerlaw.cpp
@@ -1,39 +1,40 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "regularized_powerlaw.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 template <UInt dim>
 void RegularizedPowerlaw<dim>::computeFilter(
     GridHermitian<Real, dim>& filter_coefficients) const {
   Filter<dim>::computeFilter(
       [this] CUDA_LAMBDA(Complex & coeff, VectorProxy<Real, dim> q) {
         coeff = (*this)(q);
       },
       filter_coefficients);
 }
 
 template class RegularizedPowerlaw<1>;
 template class RegularizedPowerlaw<2>;
 
 }  // namespace tamaas
diff --git a/src/surface/regularized_powerlaw.hh b/src/surface/regularized_powerlaw.hh
index 37fa0f4..04df1d1 100644
--- a/src/surface/regularized_powerlaw.hh
+++ b/src/surface/regularized_powerlaw.hh
@@ -1,76 +1,77 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef REGULARIZED_POWERLAW_H
 #define REGULARIZED_POWERLAW_H
 /* -------------------------------------------------------------------------- */
 #include "filter.hh"
 #include "grid_hermitian.hh"
 #include "static_types.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Class representing an isotropic power law spectrum
 template <UInt dim>
 class RegularizedPowerlaw : public Filter<dim> {
 public:
   /// Compute filter coefficients
   void
   computeFilter(GridHermitian<Real, dim>& filter_coefficients) const override;
 
   /// Compute a point of the PSD
   CUDA_LAMBDA inline Real operator()(const VectorProxy<Real, dim>& q_vec) const;
 
 public:
   TAMAAS_ACCESSOR(q1, UInt, Q1);
   TAMAAS_ACCESSOR(q2, UInt, Q2);
   TAMAAS_ACCESSOR(hurst, Real, Hurst);
 
 protected:
   UInt q1, q2;
   Real hurst;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline implementations                                                     */
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 CUDA_LAMBDA inline Real RegularizedPowerlaw<dim>::
 operator()(const VectorProxy<Real, dim>& q_vec) const {
   const Real C = 1.;
   const Real q = q_vec.l2norm();
 
   Real val;
 
   if (q > q2)
     val = 0;
   else
     val = C * std::pow(1 + (q / q1) * (q / q1), -(hurst + 1));
 
   return std::sqrt(val);
 }
 
 }  // namespace tamaas
 
 #endif  // REGULARIZED_POWERLAW_H
diff --git a/src/surface/surface_generator.cpp b/src/surface/surface_generator.cpp
index c63ead3..0fa0fc9 100644
--- a/src/surface/surface_generator.cpp
+++ b/src/surface/surface_generator.cpp
@@ -1,67 +1,68 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "surface_generator.hh"
 #include "partitioner.hh"
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void SurfaceGenerator<dim>::setSizes(std::array<UInt, dim> n) {
   global_size = n;
   auto local_size = Partitioner<dim>::local_size(std::move(n));
   grid.resize(local_size);
 
   Logger().get(LogLevel::debug)
       << TAMAAS_DEBUG_MSG("Local N0 " << local_size[0]);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void SurfaceGenerator<dim>::setSizes(const UInt n[dim]) {
   std::array<UInt, dim> size;
   std::copy_n(n, dim, size.begin());
   setSizes(std::move(size));
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void SurfaceGenerator<dim>::setRandomSeed(long seed) {
   mpi::bcast(&seed, 1);
   random_seed = seed;
 
   if (seed < 1)
     Logger().get(LogLevel::warning)
         << "Setting a seed < 1 is the same as seed = 1\n";
 }
 
 /* -------------------------------------------------------------------------- */
 
 template class SurfaceGenerator<1>;
 template class SurfaceGenerator<2>;
 
 }  // namespace tamaas
diff --git a/src/surface/surface_generator.hh b/src/surface/surface_generator.hh
index b75b4b5..c59fb3f 100644
--- a/src/surface/surface_generator.hh
+++ b/src/surface/surface_generator.hh
@@ -1,69 +1,70 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef SURFACE_GENERATOR_HH
 #define SURFACE_GENERATOR_HH
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include <array>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /// Class generating random surfaces
 template <UInt dim>
 class SurfaceGenerator {
 public:
   /// Default constructor
   SurfaceGenerator() = default;
   /// Construct with surface global size
   SurfaceGenerator(std::array<UInt, dim> global_size) {
     setSizes(std::move(global_size));
   }
 
   /// Default destructor
   virtual ~SurfaceGenerator() = default;
 
 public:
   /// Build surface profile (array of heights)
   virtual Grid<Real, dim>& buildSurface() = 0;
   /// Set surface sizes
   void setSizes(std::array<UInt, dim> n);
   /// Set surface sizes
   void setSizes(const UInt n[dim]);
   /// Get surface sizes
   auto getSizes() const { return global_size; }
 
   long getRandomSeed() const { return random_seed; }
   void setRandomSeed(long seed);
 
 protected:
   Grid<Real, dim> grid;
   std::array<UInt, dim> global_size{0};
   long random_seed = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
 
 #endif  // SURFACE_GENERATOR_HH
diff --git a/src/surface/surface_generator_filter.cpp b/src/surface/surface_generator_filter.cpp
index ee2d225..207be36 100644
--- a/src/surface/surface_generator_filter.cpp
+++ b/src/surface/surface_generator_filter.cpp
@@ -1,72 +1,73 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "surface_generator_filter.hh"
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void SurfaceGeneratorFilter<dim>::applyFilterOnSource() {
   GridHermitian<Real, dim> fft_white_noise(filter_coefficients.sizes(), 1);
   engine->forward(this->white_noise, fft_white_noise);
   fft_white_noise *= filter_coefficients;
   engine->backward(this->grid, fft_white_noise);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Grid<Real, dim>& SurfaceGeneratorFilter<dim>::buildSurface() {
   if (this->grid.dataSize() == 0)
     TAMAAS_EXCEPTION("the size of the grid is zero, did you call setSizes() ?");
   if (this->filter == nullptr)
     TAMAAS_EXCEPTION("filter is null, did you call setFilter() ?");
 
   // Resizing arrays
   this->white_noise.resize(this->grid.sizes());
   auto hermitian_dim =
       GridHermitian<Real, dim>::hermitianDimensions(this->grid.sizes());
   this->filter_coefficients.resize(hermitian_dim);
 
   /// Generating white noise with gaussian distribution
   this->generateWhiteNoise<normal_distribution<Real>>();
 
   /// Applying filters
   filter->computeFilter(this->filter_coefficients);
   this->applyFilterOnSource();
 
   /// Normalizing surface for hrms independent of number of points
   this->grid *= std::sqrt(this->grid.globalDataSize());
 
   return this->grid;
 }
 
 /* -------------------------------------------------------------------------- */
 template class SurfaceGeneratorFilter<1>;
 template class SurfaceGeneratorFilter<2>;
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
diff --git a/src/surface/surface_generator_filter.hh b/src/surface/surface_generator_filter.hh
index 60a302a..4e20556 100644
--- a/src/surface/surface_generator_filter.hh
+++ b/src/surface/surface_generator_filter.hh
@@ -1,91 +1,92 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 #ifndef SURFACE_GENERATOR_FILTER_H
 #define SURFACE_GENERATOR_FILTER_H
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "filter.hh"
 #include "partitioner.hh"
 #include "surface_generator.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 template <UInt dim>
 class SurfaceGeneratorFilter : public SurfaceGenerator<dim> {
 public:
   /// Default constructor
   using SurfaceGenerator<dim>::SurfaceGenerator;
   /// Construct with surface size
   // using SurfaceGenerator<dim>::SurfaceGenerator(std::array<UInt, dim> sizes);
 
 public:
   /// Build surface with Hu & Tonder algorithm
   Grid<Real, dim>& buildSurface() override;
   /// Set filter object
   void setFilter(std::shared_ptr<Filter<dim>> new_filter) {
     setSpectrum(new_filter);
   }
   /// Set spectrum
   void setSpectrum(std::shared_ptr<Filter<dim>> spectrum) { filter = spectrum; }
   /// Get spectrum
   const Filter<dim>* getSpectrum() const { return filter.get(); }
 
 protected:
   /// Apply filter coefficients on white noise
   void applyFilterOnSource();
   /// Generate white noise with given distribution
   template <typename T>
   void generateWhiteNoise();
 
 protected:
   std::shared_ptr<Filter<dim>> filter = nullptr;
   GridHermitian<Real, dim> filter_coefficients;
   Grid<Real, dim> white_noise;
   std::unique_ptr<FFTEngine> engine = FFTEngine::makeEngine();
 };
 
 /* -------------------------------------------------------------------------- */
 /* Template implementations                                                   */
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 template <typename T>
 void SurfaceGeneratorFilter<dim>::generateWhiteNoise() {
   random_engine gen(this->random_seed);
   T distribution;
 
   const auto offset = Partitioner<dim>::local_offset(white_noise);
 
   // Exhausting the random values of lower rank processes
   for (UInt i = 0; i < offset; ++i)
     distribution(gen);
 
   for (auto& noise : white_noise)
     noise = distribution(gen);
 }
 
 }  // namespace tamaas
 
 #endif
diff --git a/src/surface/surface_generator_random_phase.cpp b/src/surface/surface_generator_random_phase.cpp
index 3d40f5f..4037e9b 100644
--- a/src/surface/surface_generator_random_phase.cpp
+++ b/src/surface/surface_generator_random_phase.cpp
@@ -1,68 +1,69 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "surface_generator_random_phase.hh"
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 Grid<Real, dim>& SurfaceGeneratorRandomPhase<dim>::buildSurface() {
   if (this->grid.dataSize() == 0)
     TAMAAS_EXCEPTION("the size of the grid is zero, did you call setSizes() ?");
   if (this->filter == nullptr)
     TAMAAS_EXCEPTION("spectrum is null, did you call setSpectrum() ?");
 
   // Resizing arrays
   auto hermitian_dim =
       GridHermitian<Real, dim>::hermitianDimensions(this->grid.sizes());
   this->white_noise.resize(hermitian_dim);
   this->filter_coefficients.resize(hermitian_dim);
 
   /// Generating white noise with uniform distribution for phase
   this->template generateWhiteNoise<uniform_real_distribution<Real>>();
 
   /// Applying filters
   this->filter->computeFilter(this->filter_coefficients);
 
   Loop::loop(
       [] CUDA_LAMBDA(Complex & coeff, Real & phase) {
         coeff *= thrust::polar(1., 2 * M_PI * phase);
       },
       this->filter_coefficients, this->white_noise);
 
   this->engine->backward(this->grid, this->filter_coefficients);
 
   /// Normalizing surface for hrms independent of number of points
   this->grid *= this->grid.globalDataSize();
 
   return this->grid;
 }
 
 /* -------------------------------------------------------------------------- */
 template class SurfaceGeneratorRandomPhase<1>;
 template class SurfaceGeneratorRandomPhase<2>;
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
diff --git a/src/surface/surface_generator_random_phase.hh b/src/surface/surface_generator_random_phase.hh
index 17c7c30..8890f3d 100644
--- a/src/surface/surface_generator_random_phase.hh
+++ b/src/surface/surface_generator_random_phase.hh
@@ -1,43 +1,44 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 #ifndef SURFACE_GENERATOR_RANDOM_PHASE_H
 #define SURFACE_GENERATOR_RANDOM_PHASE_H
 /* -------------------------------------------------------------------------- */
 #include "filter.hh"
 #include "surface_generator_filter.hh"
 #include "tamaas.hh"
 /* -------------------------------------------------------------------------- */
 namespace tamaas {
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 class SurfaceGeneratorRandomPhase : public SurfaceGeneratorFilter<dim> {
 public:
   using SurfaceGeneratorFilter<dim>::SurfaceGeneratorFilter;
   /// Build surface with uniform random phase
   Grid<Real, dim>& buildSurface() override;
 };
 
 }  // namespace tamaas
 
 #endif
diff --git a/src/tamaas_info.hh b/src/tamaas_info.hh
index 1dc8c60..f8c0a9f 100644
--- a/src/tamaas_info.hh
+++ b/src/tamaas_info.hh
@@ -1,42 +1,43 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef TAMAAS_INFO_HH
 #define TAMAAS_INFO_HH
 /* -------------------------------------------------------------------------- */
 #include <string>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 struct TamaasInfo {
   static const std::string version;
   static const std::string build_type;
   static const std::string branch;
   static const std::string commit;
   static const std::string remotes;
   static const std::string diff;
   static const std::string backend;
   static const bool has_mpi;
 };
 }
 
 /* -------------------------------------------------------------------------- */
 #endif // TAMAAS_INFO_HH
diff --git a/tests/test.hh b/tests/test.hh
index ebbc355..1496ba4 100644
--- a/tests/test.hh
+++ b/tests/test.hh
@@ -1,68 +1,69 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  * Copyright (©) 2016-2022 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  * Tamaas is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Tamaas is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fftw/interface.hh"
 #include "tamaas.hh"
 #include "gtest/gtest.h"
 #include <algorithm>
 #include <array>
 #include <limits>
 #include <numeric>
 #include <thrust/complex.h>
 #include <utility>
 
 template <typename T, typename U>
 bool compare(T&& a, U&& b) {
   return std::mismatch(std::begin(a), std::end(a), std::begin(b)) ==
          std::make_pair(std::end(a), std::end(b));
 }
 
 template <typename T, typename U, typename Pred>
 bool compare(T&& a, U&& b, Pred&& pred) {
   return std::mismatch(std::begin(a), std::end(a), std::begin(b), pred) ==
          std::make_pair(std::end(a), std::end(b));
 }
 
 struct AreFloatEqual {
   tamaas::Real tolerance = 4 * std::numeric_limits<tamaas::Real>::epsilon();
   template <typename T, typename U>
   inline bool operator()(T&& x, U&& y) {
     // T y = reinterpret_cast<T>(z);
     tamaas::Real abs_max = std::max<std::decay_t<T>>(std::abs(x), std::abs(y));
     abs_max = std::max(abs_max, tamaas::Real(1.));
     return std::abs(x - y) <= (tolerance * abs_max);
   }
 };
 
 struct AreComplexEqual {
   tamaas::Real tolerance = 4 * std::numeric_limits<tamaas::Real>::epsilon();
 #ifdef TAMAAS_USE_FFTW
   inline bool operator()(const tamaas::Complex& x,
                          const fftw::helper<tamaas::Real>::complex& y) {
     auto equal = AreFloatEqual{tolerance};
     return equal(x.real(), y[0]) && equal(x.imag(), y[1]);
   }
 #endif
   inline bool operator()(const tamaas::Complex& x, const tamaas::Complex& y) {
     auto equal = AreFloatEqual{tolerance};
     return equal(x.real(), y.real()) && equal(x.imag(), y.imag());
   }
 };
diff --git a/tests/test_fftfreq.cpp b/tests/test_fftfreq.cpp
index d421383..8787ec1 100644
--- a/tests/test_fftfreq.cpp
+++ b/tests/test_fftfreq.cpp
@@ -1,88 +1,89 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include "grid_view.hh"
 #include "mpi_interface.hh"
 #include "partitioner.hh"
 #include "test.hh"
 
 #include <pybind11/embed.h>
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
 using namespace tamaas;
 namespace py = pybind11;
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTEngine, Frequencies1D) {
   mpi::sequential_guard guard{};
 
   std::array<UInt, 1> sizes = {{10}};
 
   auto freq = FFTEngine::computeFrequencies<Real, 1, false>(sizes);
 
   py::module fftfreq = py::module::import("fftfreq");
 
   std::vector<Real> reference(freq.dataSize());
   py::array py_arg(reference.size(), reference.data(), py::none());
 
   fftfreq.attr("frequencies1D")(py_arg);
 
   EXPECT_TRUE(compare(reference, freq, AreFloatEqual()))
       << "Non hermitian frequencies are wrong";
 
   auto hfreq = FFTEngine::computeFrequencies<Real, 1, true>(sizes);
   std::iota(reference.begin(), reference.end(), 0);
 
   EXPECT_TRUE(compare(reference, hfreq, AreFloatEqual()))
       << "Hermitian frequencies are wrong";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTEngine, Frequencies2D) {
   std::array<UInt, 2> sizes = {{10, 10}};
   auto global_sizes = Partitioner<2>::global_size(sizes);
 
   auto freq = FFTEngine::computeFrequencies<Real, 2, false>(sizes);
   auto hfreq = FFTEngine::computeFrequencies<Real, 2, true>(sizes);
   auto gathered = Partitioner<2>::gather(freq);
   auto hgathered = Partitioner<2>::gather(hfreq);
 
   if (mpi::rank() != 0)
     return;
 
   py::module fftfreq = py::module::import("fftfreq");
 
   std::vector<Real> reference(gathered.dataSize());
   py::array py_arg({global_sizes[0], global_sizes[1], 2u}, reference.data(),
                    py::none());
 
   fftfreq.attr("frequencies2D")(py_arg);
   EXPECT_TRUE(compare(reference, gathered, AreFloatEqual()))
       << "Non hermitian frequencies are wrong";
 
   fftfreq.attr("hfrequencies2D")(py_arg);
   EXPECT_TRUE(compare(reference, hgathered, AreFloatEqual()))
       << "Hermitian frequencies are wrong";
 }
diff --git a/tests/test_fftw.cpp b/tests/test_fftw.cpp
index 767dc21..3316933 100644
--- a/tests/test_fftw.cpp
+++ b/tests/test_fftw.cpp
@@ -1,236 +1,237 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fftw/fftw_engine.hh"
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include "grid_view.hh"
 #include "test.hh"
 
 using namespace tamaas;
 using fft = fftw::helper<Real>;
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 struct span {
   T* ptr;
   std::size_t size;
 
   ~span() { fftw::free(ptr); }
   const T* begin() const { return ptr; }
   const T* end() const { return ptr + size; }
   T* begin() { return ptr; }
   T* end() { return ptr + size; }
 
   operator T*() { return ptr; }
 };
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTEngine, FFT1D) {
   constexpr UInt size = 1000;
   FFTWEngine engine;
 
   span<Real> data{fft::alloc_real(size), size};
   span<fft::complex> solution{fft::alloc_complex(size / 2 + 1), size / 2 + 1};
 
   fftw::plan<Real> solution_plan{
       fftw::plan_1d_forward(size, data, solution, engine.flags())};
 
   std::iota(data.begin(), data.end(), 0);
   fftw::execute(solution_plan);
 
   Grid<Real, 1> grid({size}, 1);
   GridHermitian<Real, 1> result({size / 2 + 1}, 1);
 
   std::iota(grid.begin(), grid.end(), 0);
   engine.forward(grid, result);
 
   ASSERT_TRUE(compare(result, solution, AreComplexEqual()))
       << "1D FFTW transform failed";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFT2D) {
   constexpr UInt size = 100;
   constexpr UInt rsize = size * size;
   constexpr UInt csize = size * (size / 2 + 1);
   FFTWEngine engine;
 
   span<Real> data{fft::alloc_real(rsize), rsize};
   span<fft::complex> solution{fft::alloc_complex(csize), csize};
 
   fftw::plan<Real> solution_plan{
       fftw::plan_2d_forward(size, size, data, solution, engine.flags())};
 
   std::iota(data.begin(), data.end(), 0);
   fftw::execute(solution_plan);
 
   Grid<Real, 2> grid({size, size}, 1);
   GridHermitian<Real, 2> result({size, size / 2 + 1}, 1);
 
   std::iota(grid.begin(), grid.end(), 0);
   engine.forward(grid, result);
 
   ASSERT_TRUE(compare(result, solution, AreComplexEqual()))
       << "2D FFTW transform failed";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFT2DBackwards) {
   const std::ptrdiff_t N0 = 20, N1 = 20;
 
   Grid<Real, 2> real({N0, N1}, 1);
   GridHermitian<Real, 2> spectral({N0, N1 / 2 + 1}, 1);
 
   real = 1.;
 
   FFTWEngine engine;
 
   engine.forward(real, spectral);
   real = 0;
   engine.backward(real, spectral);
 
   Grid<Real, 2> reference({N0, N1}, 1);
 
   reference = 1.;
 
   ASSERT_TRUE(compare(real, reference, AreFloatEqual()));
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFT1D2Comp) {
   constexpr UInt size = 20;
 
   /// 1D single component FFT should be working here
   Grid<Real, 1> grid({size}, 2), data({size}, 1);
   std::iota(grid.begin(), grid.end(), 0);
   std::iota(data.begin(), data.end(), 0);
   GridHermitian<Real, 1> result({size / 2 + 1}, 2), solution({size / 2 + 1}, 1);
 
   FFTWEngine engine;
 
   engine.forward(grid, result);
 
   std::iota(data.begin(), data.end(), 0);
   data *= 2;
   engine.forward(data, solution);
 
   const Real tol = 200 * std::numeric_limits<Real>::epsilon();
 
   ASSERT_TRUE(
       compare(make_component_view(result, 0), solution, AreComplexEqual{tol}))
       << "1D FFTW transform with 2 components failed on 1st component";
 
   data += 1;
   engine.forward(data, solution);
 
   ASSERT_TRUE(
       compare(make_component_view(result, 1), solution, AreComplexEqual{tol}))
       << "1D FFTW transform with 2 components failed on 2nd component";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFT2D3Comp) {
   constexpr UInt size = 20;
 
   /// 2D single component FFT should be working here
   Grid<Real, 2> grid({size, size}, 3), data({size, size}, 1);
   std::iota(grid.begin(), grid.end(), 0);
   std::iota(data.begin(), data.end(), 0);
   data *= 3;
 
   GridHermitian<Real, 2> result({size, size / 2 + 1}, 3),
       solution({size, size / 2 + 1}, 1);
 
   FFTWEngine engine;
 
   engine.forward(grid, result);
 
   constexpr Real tol = 5000 * std::numeric_limits<Real>::epsilon();
 
   for (UInt i = 0; i < 3; ++i) {
     engine.forward(data, solution);
     ASSERT_TRUE(
         compare(make_component_view(result, i), solution, AreComplexEqual{tol}))
         << "2D FFTW transform with 3 components failed on " << i
         << "th component";
     data += 1;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFT2DViewTransform) {
   constexpr UInt size = 20;
 
   Grid<Real, 2> data({size, size}, 1);
   GridHermitian<Real, 2> solution({size, size / 2 + 1}, 1);
   std::iota(std::begin(data), std::end(data), 0);
 
   FFTWEngine engine;
   engine.forward(data, solution);
 
   Grid<Real, 2> grid({size, size}, 3);
   auto view = make_component_view(grid, 1);
   std::iota(view.begin(), view.end(), 0);
 
   GridHermitian<Real, 2> result({size, size / 2 + 1}, 1);
   engine.forward(view, result);
 
   constexpr Real tol = 5000 * std::numeric_limits<Real>::epsilon();
 
   ASSERT_TRUE(compare(result, solution, AreComplexEqual{tol}))
       << "Fourier transform on component view fail";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFTI1D2Comp) {
   constexpr UInt size = 20;
 
   Grid<Real, 1> grid({size}, 2);
   std::iota(grid.begin(), grid.end(), 0);
   GridHermitian<Real, 1> grid_hermitian({size / 2 + 1}, 2);
   Grid<Real, 1> result({size}, 2);
 
   FFTWEngine engine;
   engine.forward(grid, grid_hermitian);
   engine.backward(result, grid_hermitian);
 
   ASSERT_TRUE(compare(grid, result, AreFloatEqual()))
       << "1D FFTI transform with 2 components failed";
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWEngine, FFTI2D3Comp) {
   constexpr UInt size = 20;
 
   Grid<Real, 2> grid({size, size}, 3);
   std::iota(grid.begin(), grid.end(), 0);
   GridHermitian<Real, 2> grid_hermitian({size, size / 2 + 1}, 3);
   Grid<Real, 2> result({size, size}, 3);
 
   FFTWEngine engine;
   engine.forward(grid, grid_hermitian);
   engine.backward(result, grid_hermitian);
 
   ASSERT_TRUE(compare(grid, result, AreFloatEqual()))
       << "2D FFTI transform with 3 components failed";
 }
diff --git a/tests/test_grid.cpp b/tests/test_grid.cpp
index 6efa73d..d1a4c12 100644
--- a/tests/test_grid.cpp
+++ b/tests/test_grid.cpp
@@ -1,286 +1,287 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_view.hh"
 #include "model_type.hh"
 #include "test.hh"
 
 using namespace tamaas;
 
 /* -------------------------------------------------------------------------- */
 
 // Testing 1D creation
 TEST(TestGridCreation, Creation1d) {
   Grid<Real, 1> grid{{5}, 2};
   std::array<UInt, 1> correct_size{{5}};
   ASSERT_TRUE(grid.sizes() == correct_size) << "Wrong sizes";
 
   std::array<UInt, 2> correct_strides{{2, 1}};
   ASSERT_TRUE(grid.getStrides() == correct_strides) << "Wrong strides";
 }
 
 // Testing 2D creation
 TEST(TestGridCreation, Creation2d) {
   Grid<Real, 2> grid({5, 2}, 3);
   std::array<UInt, 2> correct_size{{5, 2}};
   ASSERT_TRUE(grid.sizes() == correct_size) << "Wrong sizes";
 
   std::array<UInt, 3> correct_strides{{6, 3, 1}};
   ASSERT_TRUE(grid.getStrides() == correct_strides) << "Wrong strides";
 }
 
 // Testing 3D creation
 TEST(TestGridCreation, Creation3d) {
   Grid<Real, 3> grid({8, 5, 2}, 3);
   std::array<UInt, 3> correct_size{{8, 5, 2}};
   ASSERT_TRUE(grid.sizes() == correct_size) << "Wrong sizes";
 
   std::array<UInt, 4> correct_strides{{30, 6, 3, 1}};
   ASSERT_TRUE(grid.getStrides() == correct_strides) << "Wrong strides";
 }
 
 /* -------------------------------------------------------------------------- */
 
 // Testing iterators in STL function iota
 TEST(TestGridIterators, Iota) {
   constexpr UInt N = 20;
   Grid<UInt, 1> grid({N}, 1);
   std::iota(grid.begin(), grid.end(), 0);
 
   const UInt* p = grid.getInternalData();
   for (UInt i = 0; i < N; ++i)
     ASSERT_TRUE(p[i] == i) << "Iota fill failed";
 }
 
 // Testing filling grid with OpenMP loop
 TEST(TestGridIterators, OpenMPLoops) {
   Grid<UInt, 1> grid({20}, 1);
 
 #ifndef TAMAAS_USE_CUDA
 #pragma omp parallel for
 #endif
   for (auto it = grid.begin(); it < grid.end(); ++it) {
     UInt i = it - grid.begin();
     *it = i;
   }
 
   std::vector<UInt> correct(20);
   std::iota(correct.begin(), correct.end(), 0);
 
   ASSERT_TRUE(compare(grid, correct)) << "Fill using OpenMP loop failed";
 }
 
 /* -------------------------------------------------------------------------- */
 
 // Testing access operator
 TEST(TestGridAccess, 3D) {
   Grid<UInt, 3> grid({1, 3, 5}, 3);
   std::iota(grid.begin(), grid.end(), 0);
 
   for (UInt i = 0; i < grid.sizes()[0]; ++i)
     for (UInt j = 0; j < grid.sizes()[1]; ++j)
       for (UInt k = 0; k < grid.sizes()[2]; ++k)
         for (UInt m = 0; m < grid.getNbComponents(); ++m)
           ASSERT_EQ(grid(i, j, k, m),
                     m + 3 * k + (3 * 5) * j + (3 * 5 * 3) * i);
 
   Grid<UInt, 2> grid1({5, 3}, 1);
   grid1(2, 1, 0) = 1;
   ASSERT_EQ(grid1(2 * 3 + 1), 1);
 }
 
 /* -------------------------------------------------------------------------- */
 
 // Testing scalar simple loop-based operators
 TEST(TestGridOperators, LoopOperators) {
   Grid<UInt, 1> grid({20}, 1);
   grid = 1;
   EXPECT_TRUE(std::all_of(grid.begin(), grid.end(), [](UInt x) {
     return x == 1;
   })) << "Assignement operator failed";
   grid += 1;
   EXPECT_TRUE(std::all_of(grid.begin(), grid.end(), [](UInt x) {
     return x == 2;
   })) << "Plus-equal operator failed";
 }
 
 // Testing loop-based functions with reductions
 TEST(TestGridOperators, Stats) {
   constexpr UInt n = 20;
   const UInt N = mpi::allreduce<operation::plus>(n);
 
   Grid<Real, 1> grid({n}, 1);
   std::iota(grid.begin(), grid.end(), 0);
 
   std::vector<Real> v(n);
   std::iota(v.begin(), v.end(), 0);
 
   const auto b = v.cbegin(), e = v.cend();
   Real min = mpi::allreduce<operation::min>(*std::min_element(b, e));
   Real max = mpi::allreduce<operation::max>(*std::max_element(b, e));
   Real sum = mpi::allreduce<operation::plus>(std::accumulate(b, e, 0.));
   Real mea = sum / N;
 
   std::transform(b, e, v.begin(),
                  [mea](Real v) { return (v - mea) * (v - mea); });
   Real acc = mpi::allreduce<operation::plus>(std::accumulate(b, e, 0.));
   Real var = acc / (N - 1);
 
   EXPECT_DOUBLE_EQ(grid.min(), min) << "Minimum function failed";
   EXPECT_DOUBLE_EQ(grid.max(), max) << "Maximum function failed";
   EXPECT_DOUBLE_EQ(grid.sum(), sum) << "Sum function failed";
   EXPECT_DOUBLE_EQ(grid.mean(), mea) << "Mean function failed";
   EXPECT_DOUBLE_EQ(grid.var(), var) << "Var function failed";
 }
 
 /* -------------------------------------------------------------------------- */
 
 TEST(TestGridView, View2D) {
   Grid<UInt, 3> grid3d({10, 10, 10}, 3);
   std::iota(grid3d.begin(), grid3d.end(), 0);
 
   for (UInt i : Loop::range(10)) {
     auto grid_view = make_view(grid3d, i);
     std::vector<UInt> reference(300);
     std::iota(reference.begin(), reference.end(), 300 * i);
     EXPECT_TRUE(
         std::equal(grid_view.begin(), grid_view.end(), reference.begin()))
         << "View on slice fail";
   }
 }
 
 TEST(TestGridView, ViewOnComponent) {
   Grid<UInt, 3> grid3d({10, 9, 8}, 3), solution({10, 9, 8}, 3);
   grid3d = solution = 0;
 
   auto view = make_component_view(grid3d, 2u);
   std::iota(view.begin(), view.end(), 0);
 
   for (UInt i = 0; i < solution.getNbPoints(); ++i)
     solution(3 * i + 2) = i;
 
   EXPECT_TRUE(std::equal(grid3d.begin(), grid3d.end(), solution.begin()))
       << "View on components fail";
 
   view(9, 8, 7) = 1;
   ASSERT_EQ(grid3d(9, 8, 7, 2), 1);
 }
 
 TEST(TestGridView, ViewCopy) {
   Grid<UInt, 3> grid3d({10, 10, 10}, 2);
   Grid<UInt, 1> copy, solution({10}, 1);
   auto view_on_slice = make_view(grid3d, 3, 4);
   Grid<UInt, 1>* view_on_slice_ptr = &view_on_slice;
   auto view = make_component_view(*view_on_slice_ptr, 1u);
   std::iota(view.begin(), view.end(), 0);
   std::iota(solution.begin(), solution.end(), 0);
   copy = view;
   EXPECT_TRUE(std::equal(copy.begin(), copy.end(), solution.begin()))
       << "Copy of view fail";
 }
 
 TEST(TestGridView, HigherOrderView) {
   Grid<UInt, 2> grid({10, 10}, 2);
   std::iota(grid.begin(), grid.end(), 0);
   GridView<Grid, UInt, 2, 3> view(grid, {}, -1);
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), view.begin()))
       << "Higher order view fail";
 }
 
 /* -------------------------------------------------------------------------- */
 
 struct BroadcastSet123 {
   CUDA_LAMBDA inline void operator()(VectorProxy<UInt, 3> v) {
     v(0) = 1;
     v(1) = 2;
     v(2) = 3;
   }
 };
 
 TEST(TestGridOperators, BroadcastOperators) {
   Grid<UInt, 2> grid({10, 10}, 3), solution({10, 10}, 3);
   auto set = BroadcastSet123();
 
   // Filling up solution
   Loop::loop(set, range<VectorProxy<UInt, 3>>(solution));
 
   Vector<UInt, 3> v;
   v(0) = 1;
   v(1) = 2;
   v(2) = 3;
 
   grid = v;
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), solution.begin()))
       << "Broadcast assignement failure";
 
   v(1) = 1;
   v(2) = 1;
 
   solution += 1;
   grid += v;
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), solution.begin()))
       << "Broadcast += failure";
 
   solution -= 1;
   grid -= v;
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), solution.begin()))
       << "Broadcast -= failure";
 
   v(1) = 2;
   v(2) = 3;
 
   solution *= solution;
   grid *= v;
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), solution.begin()))
       << "Broadcast *= failure";
 
   Loop::loop(set, range<VectorProxy<UInt, 3>>(solution));
   grid /= v;
 
   EXPECT_TRUE(std::equal(grid.begin(), grid.end(), solution.begin()))
       << "Broadcast /= failure";
 }
 
 TEST(TestAllocation, HardType) {
   std::array<UInt, 2> dims{4, 5};
   auto grid = allocateGrid<model_type::basic_2d, true, Real>(dims, 1);
   static_assert(
       std::is_same<decltype(grid), std::unique_ptr<Grid<Real, 2>>>::value,
       "allocation type incorrect");
   EXPECT_TRUE(std::equal(dims.begin(), dims.end(), grid->sizes().begin()));
   EXPECT_EQ(grid->getNbComponents(), 1);
 }
 
 TEST(TestAllocation, SoftType) {
   std::array<UInt, 2> dims{4, 5};
   auto grid = allocateGrid<true, Real>(model_type::basic_2d, dims, 1);
   static_assert(
       std::is_same<decltype(grid), std::unique_ptr<GridBase<Real>>>::value,
       "allocation type incorrect");
   EXPECT_EQ(grid->dataSize(), 20);
   EXPECT_EQ(grid->getNbComponents(), 1);
 }
diff --git a/tests/test_integration.cpp b/tests/test_integration.cpp
index bb3dda5..3d344dc 100644
--- a/tests/test_integration.cpp
+++ b/tests/test_integration.cpp
@@ -1,175 +1,176 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fft_engine.hh"
 #include "integration/accumulator.hh"
 #include "mpi_interface.hh"
 #include "partitioner.hh"
 #include "test.hh"
 #include <cmath>
 #include <expolit/expolit>
 #include <functional>
 /* -------------------------------------------------------------------------- */
 using namespace tamaas;
 namespace ex = expolit;
 
 static Real tol = 1e-13;
 
 class AccumulatorTest : public ::testing::Test {
 protected:
   void SetUp() override {
     nodal_values.resize(n);
 
     for (auto&& grid : nodal_values) {
       grid.setNbComponents(6);
       grid.resize(Partitioner<2>::local_size({nh, nh}));
       grid = 1;
     }
 
     accumulator.makeUniformMesh(nodal_values.size(), size);
     wavevectors = FFTEngine::computeFrequencies<Real, 2, true>({nh, nh});
   }
 
   mpi::sequential_guard guard;
   UInt n = 10, nh = 10;
   Real size = 3;
   std::vector<GridHermitian<Real, 2>> nodal_values;
   Grid<Real, 2> wavevectors;
   Accumulator<model_type::volume_2d, SymMatrixProxy<Complex, 3>> accumulator;
 };
 
 TEST_F(AccumulatorTest, uniformMesh) {
   auto& pos = this->accumulator.nodePositions();
   std::vector<Real> sol(pos.size());
   std::iota(sol.begin(), sol.end(), 0);
   std::transform(sol.begin(), sol.end(), sol.begin(),
                  [&](auto& x) { return size * x / (sol.size() - 1); });
   ASSERT_TRUE(compare(sol, pos, AreFloatEqual())) << "Uniform mesh fail";
 }
 
 // Litteral type
 using Q = ex::Litteral<struct Q_>;
 
 TEST_F(AccumulatorTest, forward) {
   ASSERT_TRUE(compare(this->nodal_values.front().sizes(),
                       this->wavevectors.sizes(), std::equal_to<void>()))
       << "Size mismatch between nodal value and wavevectors";
 
   // Setup for layer checking
   std::vector<int> layers_seen, layers_to_see(n);
   std::iota(layers_to_see.begin(), layers_to_see.end(), 0);
 
   // Setup for integral checking
   constexpr Q q;
   constexpr auto z = ex::Polynomial<Real, 1>({0, 1});
   constexpr auto g0 = ex::exp(q * z);
   constexpr auto g1 = q * z * ex::exp(q * z);
 
   for (auto&& tuple :
        accumulator.forward(this->nodal_values, this->wavevectors)) {
     auto&& l = std::get<0>(tuple);
     auto&& xl_ = std::get<1>(tuple);
     auto&& acc_g0 = std::get<2>(tuple);
     auto&& acc_g1 = std::get<3>(tuple);
     layers_seen.push_back(l);
 
     // fundamental mode
     auto testing = acc_g0(0, 0, 0);
     EXPECT_NEAR(testing.real(), xl_, tol) << "Fundamental mode G0 fail";
     testing = acc_g1(0, 0, 0);
     EXPECT_NEAR(testing.real(), 0, tol) << "Fundamental mode G1 fail";
 
     // other modes
     testing = acc_g0(1, 0, 0);
     EXPECT_NEAR(testing.real(), acc_g0(0, 1, 0).real(), tol) << "Symmetry fail";
     EXPECT_NEAR(testing.imag(), acc_g0(0, 1, 0).imag(), tol) << "Symmetry fail";
 
     testing = acc_g0(1, 1, 0);
     Real sqrt_two = std::sqrt(Real(2));
     auto ref_value = ex::definite_integral(
         std::pair<Real, Real>(0, xl_),
         ex::substitute<Q::tag>(ex::Constant<Real>({sqrt_two}), g0));
     EXPECT_NEAR(testing.real(), ref_value, tol)
         << "Integration of exp(qy)*ϕ(y) fail";
 
     testing = acc_g1(1, 1, 0);
     ref_value = ex::definite_integral(
         std::pair<Real, Real>(0, xl_),
         ex::substitute<Q::tag>(ex::Constant<Real>({sqrt_two}), g1));
     EXPECT_NEAR(testing.real(), ref_value, tol)
         << "Integration of qy*exp(qy)*ϕ(y) fail";
   }
 
   EXPECT_TRUE(compare(layers_seen, layers_to_see))
       << "Did not see correct layers";
 }
 
 TEST_F(AccumulatorTest, backward) {
   ASSERT_TRUE(compare(this->nodal_values.front().sizes(),
                       this->wavevectors.sizes(), std::equal_to<void>()))
       << "Size mismatch between nodal value and wavevectors";
 
   // Setup for layer checking
   std::vector<int> layers_seen, layers_to_see(n);
   std::iota(layers_to_see.rbegin(), layers_to_see.rend(), 0);
 
   // Setup for integral checking
   constexpr Q q;
   constexpr auto z = ex::Polynomial<Real, 1>({0, 1});
   constexpr auto g0 = ex::exp(q * (z * (-1)));
   constexpr auto g1 = q * z * ex::exp(q * ((-1) * z));
 
   for (auto&& tuple : accumulator.backward(nodal_values, wavevectors)) {
     auto&& l = std::get<0>(tuple);
     auto&& xl_ = std::get<1>(tuple);
     auto&& acc_g0 = std::get<2>(tuple);
     auto&& acc_g1 = std::get<3>(tuple);
     layers_seen.push_back(l);
 
     // fundamental mode
     auto testing = acc_g0(0, 0, 0);
     EXPECT_NEAR(testing.real(), size - xl_, tol) << "Fundamental mode G0 fail";
     testing = acc_g1(0, 0, 0);
     EXPECT_NEAR(testing.real(), 0, tol) << "Fundamental mode G1 fail";
 
     // other modes
     testing = acc_g0(1, 0, 0);
     EXPECT_NEAR(testing.real(), acc_g0(0, 1, 0).real(), tol) << "Symmetry fail";
     EXPECT_NEAR(testing.imag(), acc_g0(0, 1, 0).imag(), tol) << "Symmetry fail";
 
     testing = acc_g0(1, 1, 0);
     auto ref_value = ex::definite_integral(
         std::make_pair(xl_, size),
         ex::substitute<Q::tag>(ex::Constant<Real>({std::sqrt(2)}), g0));
     EXPECT_NEAR(testing.real(), ref_value, tol)
         << "Integration of exp(-qy)*ϕ(y) fail";
 
     testing = acc_g1(1, 1, 0);
     ref_value = ex::definite_integral(
         std::make_pair(xl_, size),
         ex::substitute<Q::tag>(ex::Constant<Real>({std::sqrt(2)}), g1));
     EXPECT_NEAR(testing.real(), ref_value, tol)
         << "Integration of qy*exp(-qy)*ϕ(y) fail";
   }
 
   EXPECT_TRUE(compare(layers_seen, layers_to_see))
       << "Did not see correct layers";
 }
diff --git a/tests/test_loop.cpp b/tests/test_loop.cpp
index a6101e0..0d058bf 100644
--- a/tests/test_loop.cpp
+++ b/tests/test_loop.cpp
@@ -1,399 +1,400 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 #include "grid_view.hh"
 #include "loop.hh"
 #include "mpi_interface.hh"
 #include "static_types.hh"
 #include "test.hh"
 /* -------------------------------------------------------------------------- */
 /* WARNING: here we cannot use lambdas for tests because GoogleTest declares  */
 /* test functions as private members of classes which is incompatible with    */
 /* cuda's extended lambdas. I know... it's f*cking stupid                     */
 /* -------------------------------------------------------------------------- */
 
 using namespace tamaas;
 
 template <typename T>
 struct AddOneInplace {
   CUDA_LAMBDA void operator()(T& x) { x += 1; }
 };
 
 // Testing loops on one grid
 TEST(TestLoops, OneArgument) {
   Grid<Real, 1> grid({20}, 1);
   Grid<Real, 1> solution({20}, 1);
 
   auto add_one = [](auto x) { return x + 1; };
 
   std::iota(grid.begin(), grid.end(), 1);
 
   // Makeing solution
   std::transform(grid.begin(), grid.end(), solution.begin(), add_one);
 
   auto add_one_inplace = AddOneInplace<Real>();
 
   Loop::loop(add_one_inplace, grid);
 
   ASSERT_TRUE(compare(grid, solution, AreFloatEqual()))
       << "One argument loop failed";
 }
 
 struct PrimalTest {
   CUDA_LAMBDA void operator()(Int& primal, Int& val) {
     val = (primal > 0) ? -1 : 1;
   }
 };
 
 // Testing loops on two grids
 TEST(TestLoops, TwoArguments) {
   // Why no ints?
   Grid<Int, 2> grid({20, 20}, 1);
   Grid<Int, 2> primal({20, 20}, 1);
   Grid<Int, 2> solution({20, 20}, 1);
 
   primal(0, 0) = 1;
   primal(0, 1) = 1;
   primal(1, 0) = 1;
   primal(1, 1) = 1;
 
   std::transform(primal.begin(), primal.end(), solution.begin(),
                  [](Int& primal) { return (primal > 0) ? -1 : 1; });
 
   auto primal_test = PrimalTest();
 
   Loop::loop(primal_test, primal, grid);
 
   ASSERT_TRUE(compare(solution, grid)) << "Two argument loop failed";
 }
 
 struct AssignUInt {
   CUDA_LAMBDA void operator()(UInt& x, UInt i) { x = i; }
 };
 
 // Testing an enumeration
 TEST(TestLoops, Enumeration) {
   Grid<UInt, 1> grid({100}, 1);
   Grid<UInt, 1> solution({100}, 1);
   std::iota(solution.begin(), solution.end(), 0);
 
   auto assign_uint = AssignUInt();
 
   Loop::loop(assign_uint, grid, Loop::range(100));
 
   ASSERT_TRUE(compare(solution, grid)) << "Enumeration loop failed";
 }
 
 /* -------------------------------------------------------------------------- */
 
 struct Identity {
   CUDA_LAMBDA UInt operator()(UInt& x) const { return x; }
 };
 
 // Testing one grid reductions
 TEST(TestReductions, OneArgument) {
   Grid<UInt, 1> grid({6}, 1);
   std::iota(grid.begin(), grid.end(), 1);
 
   const auto id = Identity();
 
   // Sum reduction
   UInt sol = mpi::allreduce<operation::plus>(
       std::accumulate(grid.begin(), grid.end(), 0, std::plus<>()));
   UInt red = Loop::reduce<operation::plus>(id, grid);
   ASSERT_TRUE(sol == red) << "Addition reduction failed on one argument";
 
   // Product reduction
   sol = mpi::allreduce<operation::times>(
       std::accumulate(grid.begin(), grid.end(), 1, std::multiplies<>()));
   red = Loop::reduce<operation::times>(id, grid);
   ASSERT_TRUE(sol == red) << "Multiplication reduction failed on one argument";
 
   // Min reduction
   sol = mpi::allreduce<operation::min>(
       *std::min_element(grid.begin(), grid.end()));
   red = Loop::reduce<operation::min>(id, grid);
   ASSERT_TRUE(sol == red) << "Min reduction failed on one argument";
 
   // Max reduction
   sol = mpi::allreduce<operation::max>(
       *std::max_element(grid.begin(), grid.end()));
   red = Loop::reduce<operation::max>(id, grid);
   ASSERT_TRUE(sol == red) << "Max reduction failed on one argument";
 }
 
 struct AssignReduce {
   CUDA_LAMBDA UInt operator()(UInt& x, UInt i) {
     x = i;
     return x;
   }
 };
 
 TEST(TestReductions, ReduceAndTransform) {
   UInt n = 20;
   Grid<UInt, 1> grid({n}, 1), solution({n}, 1);
   std::iota(solution.begin(), solution.end(), 0);
   UInt sum_value = mpi::allreduce<operation::plus>((n - 1) * n / 2);
 
   auto assign_reduce = AssignReduce{};
   UInt res = Loop::reduce<operation::plus>(assign_reduce, grid, Loop::range(n));
 
   EXPECT_EQ(res, sum_value) << "Reduction failed";
   EXPECT_TRUE(compare(grid, solution)) << "Assign failed";
 }
 
 struct PrimalReduce {
   CUDA_LAMBDA UInt operator()(UInt& p, UInt& val) { return (p > 0) ? val : 0; }
 };
 
 TEST(TestReductions, TwoArguments) {
   Grid<UInt, 1> grid({20}, 1);
   Grid<UInt, 1> primal({20}, 1);
   grid = 1;
   primal(0) = 1;
   primal(1) = 1;
 
   auto primal_reduce = PrimalReduce();
 
   // Reduce on values where primal > 0
   UInt red = Loop::reduce<operation::plus>(primal_reduce, primal, grid);
   ASSERT_TRUE(red == mpi::allreduce<operation::plus>(UInt{2}))
       << "Two args reduction failed";
 }
 
 /* -------------------------------------------------------------------------- */
 
 TEST(TestRange, type_trait) {
   Grid<UInt, 1> grid({1}, 1);
   auto gridrange = range<VectorProxy<UInt, 1>>(grid);
 
   static_assert(decltype(gridrange)::is_valid_container<Grid<UInt, 1>>::value,
                 "is_valid_container Type trait is wrong");
 
   static_assert(
       not decltype(gridrange)::is_valid_container<Grid<Real, 1>&>::value,
       "is_valid_container Type trait is wrong");
 
   static_assert(not Range<VectorProxy<Real, 1>, Real,
                           1>::is_valid_container<decltype(grid)>::value,
                 "is_valid_container Type trait is wrong");
 }
 
 struct AssignOne {
   CUDA_LAMBDA void operator()(VectorProxy<UInt, 1> x) { x = 1; }
   CUDA_LAMBDA void operator()(UInt& x) { x = 1; }
   CUDA_LAMBDA void operator()(VectorProxy<UInt, 3> v) { v(2) = 1; }
   CUDA_LAMBDA void operator()(VectorProxy<UInt, 2> v) { v = 1; }
 };
 
 TEST(TestRange, headless) {
   if (mpi::rank() != 0)
     GTEST_SKIP() << "Skipping because not root process";
 
   Grid<UInt, 1> grid({10}, 1), solution({10}, 1);
   std::fill(++solution.begin(), solution.end(), 1);
   auto gridrange = range<VectorProxy<UInt, 1>>(grid).headless();
   auto assign_one = AssignOne{};
   Loop::loop(assign_one, gridrange);
   ASSERT_TRUE(compare(grid, solution)) << "Headless fail";
 }
 
 template <typename T>
 using WrapVector = VectorProxy<T, 2>;
 
 struct AddOneVector {
   CUDA_LAMBDA void operator()(WrapVector<UInt> x) { x(0) += 1; }
 };
 
 TEST(TestStridedLoops, VectorStride) {
   Grid<UInt, 2> grid({10, 10}, 2);
   std::iota(grid.begin(), grid.end(), 1);
 
   Grid<UInt, 2> solution({10, 10}, 2);
   solution = grid;
 
   std::for_each(solution.begin(), solution.end(), [](UInt& x) {
     if (x % 2 == 1)
       x += 1;
   });
 
   auto add_one_inplace = AddOneVector();
 
   Loop::loop(add_one_inplace, range<WrapVector<UInt>>(grid));
 
   ASSERT_TRUE(compare(solution, grid)) << "Static vector strided loop failed";
 }
 
 template <typename T>
 using WrapMatrix = MatrixProxy<T, 2, 2>;
 
 struct SetOneMatrix {
   CUDA_LAMBDA void operator()(WrapMatrix<UInt> x) {
     x(0, 0) = 1;
     x(1, 1) = 1;
   }
 };
 
 TEST(TestStridedLoops, MatrixStride) {
   Grid<UInt, 2> grid({10, 10}, 4);
   Grid<UInt, 2> solution({10, 10}, 4);
   std::iota(solution.begin(), solution.end(), 0);
 
   std::for_each(solution.begin(), solution.end(), [](UInt& x) {
     if (x % 4 == 0 || x % 4 == 3)
       x = 1;
     else
       x = 0;
   });
 
   auto set_one = SetOneMatrix();
 
   Loop::loop(set_one, range<WrapMatrix<UInt>>(grid));
 
   ASSERT_TRUE(compare(solution, grid)) << "Static matrix strided loop failed";
 }
 
 struct VectorReduction {
   CUDA_LAMBDA Vector<UInt, 3> operator()(const VectorProxy<UInt, 3>& v) const {
     return v;
   }
 };
 
 struct BroadcastSet123 {
   CUDA_LAMBDA inline void operator()(VectorProxy<UInt, 3> v) const {
     v(0) = 1;
     v(1) = 2;
     v(2) = 3;
   }
 };
 
 TEST(TestStridedReduction, VectorReduce) {
   Grid<UInt, 2> grid({10, 10}, 3);
 
   Loop::loop(BroadcastSet123(), range<VectorProxy<UInt, 3>>(grid));
 
   auto res = Loop::reduce<operation::plus>(VectorReduction(),
                                            range<VectorProxy<UInt, 3>>(grid));
 
   auto reduce = [](UInt x) { return mpi::allreduce<operation::plus>(x); };
   ASSERT_EQ(res(0), reduce(100));
   ASSERT_EQ(res(1), reduce(200));
   ASSERT_EQ(res(2), reduce(300));
 }
 
 struct ScalarReduce {
   CUDA_LAMBDA UInt operator()(UInt& x) { return x; }
 };
 
 TEST(TestViewReduction, ScalarReduce) {
   Grid<UInt, 2> grid({10, 10}, 3);
   Loop::loop(BroadcastSet123(), range<VectorProxy<UInt, 3>>(grid));
 
   auto view = make_component_view(grid, 2);
 
   auto scalar_reduce = ScalarReduce{};
   UInt res = Loop::reduce<operation::plus>(scalar_reduce, view);
   EXPECT_EQ(res, mpi::allreduce<operation::plus>(UInt{300}))
       << "Reduce on component view fail";
 }
 
 TEST(TestViewReduction, VectorReduce) {
   Grid<UInt, 2> grid({10, 10}, 3);
   auto view2 = make_view(grid, 0);
 
   Loop::loop(BroadcastSet123(), range<VectorProxy<UInt, 3>>(view2));
 
   auto res2 = Loop::reduce<operation::plus>(VectorReduction(),
                                             range<VectorProxy<UInt, 3>>(view2));
   auto reduce = [](UInt x) { return mpi::allreduce<operation::plus>(x); };
   EXPECT_EQ(res2(0), reduce(10));
   EXPECT_EQ(res2(1), reduce(20));
   EXPECT_EQ(res2(2), reduce(30));
 }
 
 TEST(TestViewLoop, ScalarLoop) {
   Grid<UInt, 2> grid({10, 10}, 3), solution({10, 10}, 3);
   auto view = make_component_view(grid, 2);
 
   auto assign_one = AssignOne{};
   Loop::loop(assign_one, view);
   Loop::loop(assign_one, range<VectorProxy<UInt, 3>>(solution));
 
   ASSERT_TRUE(compare(grid, solution)) << "View loop fail";
 }
 
 TEST(TestLoopChecks, Components) {
   Grid<UInt, 2> grid({10, 10}, 3);
 
   auto assign_one = AssignOne();
   EXPECT_THROW(Loop::loop(assign_one, range<VectorProxy<UInt, 2>>(grid)),
                Exception)
       << "Broken check on number of components";
 }
 
 struct CopyValues {
   CUDA_LAMBDA auto operator()(UInt& x, UInt& y) { x = y; }
   CUDA_LAMBDA auto operator()(VectorProxy<UInt, 2> x, VectorProxy<UInt, 1> y) {
     x(0) = y(0);
   }
 };
 
 TEST(TestLoopChecks, LoopSize) {
   Grid<UInt, 1> grid({10}, 2), other({10}, 1);
 
   CopyValues func;
 
   EXPECT_THROW(Loop::loop(func, grid, other), Exception)
       << "Check on loop size without ranges fail";
   other.resize({11});
   EXPECT_THROW(Loop::loop(func, range<VectorProxy<UInt, 2>>(grid),
                           range<VectorProxy<UInt, 1>>(other)),
                Exception)
       << "Check on loop size with ranges fail";
 
   Grid<UInt, 2> twod({10, 11}, 2);
   auto view = make_view(twod, 0);
   EXPECT_THROW(Loop::loop(func, grid, view), Exception)
       << "Check on loop size with view fail";
 }
 
 struct ReduceAndTransform {
   CUDA_LAMBDA UInt operator()(VectorProxy<UInt, 2> x, UInt /*i*/) {
     x += 1;
     return x(0) + x(1);
   }
 };
 
 TEST(TestReductions, ReduceAndTransformVector) {
   UInt n = 20;
   Grid<UInt, 1> grid({n}, 2), solution({n}, 2);
   std::iota(solution.begin(), solution.end(), 1);
   std::iota(grid.begin(), grid.end(), 0);
   UInt sum_value = mpi::allreduce<operation::plus>((2 * n + 1) * 2 * n / 2);
 
   auto reduce_transform = ReduceAndTransform();
   UInt res = Loop::reduce<operation::plus>(
       reduce_transform, range<VectorProxy<UInt, 2>>(grid), Loop::range(n));
 
   EXPECT_EQ(res, sum_value) << "Reduction failed";
   EXPECT_TRUE(compare(grid, solution)) << "Assign failed";
 }
diff --git a/tests/test_model.cpp b/tests/test_model.cpp
index 4f78cfa..b15c80d 100644
--- a/tests/test_model.cpp
+++ b/tests/test_model.cpp
@@ -1,160 +1,161 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "isotropic_hardening.hh"
 #include "logger.hh"
 #include "model_factory.hh"
 #include "mpi_interface.hh"
 #include "test.hh"
 #include <random>
 /* -------------------------------------------------------------------------- */
 
 using namespace tamaas;
 
 TEST(TestModel, applyElasticity) {
   auto model =
       ModelFactory::createModel(model_type::volume_2d, {1., 1., 1.}, {1, 1, 1});
 
   Grid<Real, 3> gradient({1, 1, 1}, 9), stress({1, 1, 1}, 9);
 
   // Random data objects
   std::random_device rnd;
   std::mt19937 mt(rnd());
   std::normal_distribution<> dis(0, 1);
 
   // Filling gradient with random data (sequential)
   for (auto& du : gradient)
     du = dis(mt);
 
   std::uniform_real_distribution<> unif(0, 0.5);
   model->setElasticity(std::abs(dis(mt)) * unif(mt), unif(mt));
 
   // Computing stresses with seperate array
   model->applyElasticity(stress, gradient);
 
   // Checking correct isotropic elasticity
   auto mu = model->getShearModulus(), nu = model->getPoissonRatio();
   auto lambda = 2 * mu * nu / (1 - 2 * nu);
 
   MatrixProxy<Real, 3, 3> grad(gradient(0));
   auto trace = grad.trace();
 
   Matrix<Real, 3, 3> sigma;
 
   for (UInt i = 0; i < 3; ++i)
     for (UInt j = 0; j < 3; ++j)
       sigma(i, j) = (i == j) * lambda * trace + mu * (grad(i, j) + grad(j, i));
 
   EXPECT_TRUE(compare(stress, sigma, AreFloatEqual())) << "Elasticity fail";
 
   // Computing stress with same array
   model->applyElasticity(gradient, gradient);
 
   EXPECT_TRUE(compare(gradient, stress, AreFloatEqual()))
       << "Applying elasticity in-place fail";
 }
 
 TEST(TestModel, applyElasticitySym) {
   auto model =
       ModelFactory::createModel(model_type::volume_2d, {1., 1., 1.}, {1, 1, 1});
 
   Grid<Real, 3> gradient({1, 1, 1}, 6), stress({1, 1, 1}, 6);
 
   // Random data objects
   std::random_device rnd;
   std::mt19937 mt(rnd());
   std::normal_distribution<> dis(0, 1);
 
   // Filling gradient with random data (sequential)
   for (auto& du : gradient)
     du = dis(mt);
 
   std::uniform_real_distribution<> unif(0, 0.5);
   model->setElasticity(std::abs(dis(mt)) * unif(mt), unif(mt));
 
   // Computing stresses with seperate array
   model->applyElasticity(stress, gradient);
 
   // Checking correct isotropic elasticity
   auto mu = model->getShearModulus(), nu = model->getPoissonRatio();
   auto lambda = 2 * mu * nu / (1 - 2 * nu);
 
   SymMatrixProxy<Real, 3> sym_grad(gradient(0));
   auto grad = dense(sym_grad);
   auto trace = grad.trace();
 
   Matrix<Real, 3, 3> sigma;
 
   for (UInt i = 0; i < 3; ++i)
     for (UInt j = 0; j < 3; ++j)
       sigma(i, j) = (i == j) * lambda * trace + mu * (grad(i, j) + grad(j, i));
 
   EXPECT_TRUE(compare(stress, symmetrize(sigma), AreFloatEqual()))
       << "Elasticity fail";
 
   // Computing stress with same array
   model->applyElasticity(gradient, gradient);
 
   EXPECT_TRUE(compare(gradient, stress, AreFloatEqual()))
       << "Applying elasticity in-place fail";
 }
 
 TEST(TestIsotropicHardening, computePlasticIncrement) {
   mpi::sequential_guard guard;
 
   auto model =
       ModelFactory::createModel(model_type::volume_2d, {1., 1., 1.}, {1, 1, 1});
   auto sigma_0 = 1., h = 0.1;
   IsotropicHardening<model_type::volume_2d> hardening(model.get(), sigma_0, h);
   Grid<Real, 3> strain({1, 1, 1}, 6), strain_increment({1, 1, 1}, 6),
       plastic_strain_increment({1, 1, 1}, 6), solution({1, 1, 1}, 6);
   auto E = model->getYoungModulus();
   auto nu = model->getPoissonRatio();
   auto mu = model->getShearModulus();
 
   // uniform tension state
   Real sigma = 0.9;
   strain_increment(0, 0, 0, 0) = sigma / E;
   strain_increment(0, 0, 0, 1) = -nu * sigma / E;
   strain_increment(0, 0, 0, 2) = -nu * sigma / E;
 
   hardening.computePlasticIncrement<false>(plastic_strain_increment, strain,
                                            strain_increment);
   // just checking everything is zero
   EXPECT_TRUE(compare(solution, plastic_strain_increment, AreFloatEqual()))
       << "Elastic radial return fail (plastic increment)";
 
   // uniform tension state
   sigma = 1.1;
   strain_increment(0, 0, 0, 0) = sigma / E;
   strain_increment(0, 0, 0, 1) = -nu * sigma / E;
   strain_increment(0, 0, 0, 2) = -nu * sigma / E;
 
   hardening.computePlasticIncrement<false>(plastic_strain_increment, strain,
                                            strain_increment);
   Real a = (sigma - sigma_0) / (3 * mu + h);
   solution(0, 0, 0, 0) = a;
   solution(0, 0, 0, 1) = -a / 2;
   solution(0, 0, 0, 2) = -a / 2;
 
   EXPECT_TRUE(compare(solution, plastic_strain_increment, AreFloatEqual()))
       << "Plastic radial return fail (plastic increment)";
 }
diff --git a/tests/test_mpi.cpp b/tests/test_mpi.cpp
index 0c7c2cc..33c885d 100644
--- a/tests/test_mpi.cpp
+++ b/tests/test_mpi.cpp
@@ -1,204 +1,205 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fftw/mpi/fftw_mpi_engine.hh"
 #include "grid.hh"
 #include "grid_hermitian.hh"
 #include "grid_view.hh"
 #include "partitioner.hh"
 #include "test.hh"
 
 #include <fftw3-mpi.h>
 
 using namespace tamaas;
 using fft = fftw::helper<Real>;
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 struct span {
   T* ptr;
   std::size_t size;
 
   ~span() { fftw::free(ptr); }
   const T* begin() const { return ptr; }
   const T* end() const { return ptr + size; }
   T* begin() { return ptr; }
   T* end() { return ptr + size; }
 
   operator T*() { return ptr; }
 };
 
 /* -------------------------------------------------------------------------- */
 TEST(TestMPIInterface, SequentialGuard) {
   mpi::sequential_guard guard;
   EXPECT_EQ(mpi::rank(), 0);
   EXPECT_EQ(mpi::size(), 1);
   ASSERT_EQ(mpi::comm::world()._comm, MPI_COMM_SELF);
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWInterface, MPISizes) {
   const std::ptrdiff_t N0 = 100, N1 = 100;
   std::ptrdiff_t local_n0, local_n0_start;
   auto alloc_local = fftw_mpi_local_size_2d(N0, N1 / 2 + 1, mpi::comm::world(),
                                             &local_n0, &local_n0_start);
 
   const std::ptrdiff_t N[] = {N0, N1 / 2 + 1};
   auto sizes = fftw::mpi::local_size_many(2, N, 1);
 
   ASSERT_EQ(std::get<0>(sizes), alloc_local);
   ASSERT_EQ(std::get<1>(sizes), local_n0);
   ASSERT_EQ(std::get<2>(sizes), local_n0_start);
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestPartitioner, LocalSizes) {
   const std::ptrdiff_t N0 = 100, N1 = 100;
   std::ptrdiff_t local_n0, local_n0_start;
   fftw_mpi_local_size_2d(N0, N1 / 2 + 1, mpi::comm::world(), &local_n0,
                          &local_n0_start);
 
   auto local_size = Partitioner<2>::local_size({N0, N1 / 2 + 1});
   ASSERT_EQ(local_size[0], local_n0);
   ASSERT_EQ(local_size[1], N1 / 2 + 1);
   ASSERT_EQ(Partitioner<2>::local_offset({N0, N1 / 2 + 1}), local_n0_start);
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestPartitioner, LocalOffsetInGrid) {
   std::array<UInt, 2> N = {10, 10};
   std::array<UInt, 2> Nglobal = {mpi::allreduce(N.front()), N.back()};
 
   Grid<UInt, 2> local(N, 1), global(Nglobal, 1);
   auto offset = Partitioner<2>::local_offset(local);
   auto local_n0_start = Partitioner<2>::local_offset(Nglobal);
   ASSERT_EQ(offset, &global(local_n0_start, 0) - &global(0, 0));
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestPartitioner, Scatter) {
   std::array<UInt, 2> N = {10, 10};
   Grid<Real, 2> global(N, 3);
 
   if (mpi::rank() != 0)
     global.resize({0, 0});
 
   std::iota(global.begin(), global.end(), 0);
 
   auto local = Partitioner<2>::scatter(global);
 
   auto gathered = Partitioner<2>::gather(local);
 
   if (mpi::rank() != 0)
     return;
 
   ASSERT_TRUE(compare(gathered, global, AreFloatEqual()));
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWMPIEngine, BasicTransform) {
   const std::ptrdiff_t N0 = 60, N1 = 60;
   auto local_size = Partitioner<2>::local_size({N0, N1 / 2 + 1});
 
   Grid<Real, 2> real({local_size[0], N1}, 1);
   GridHermitian<Real, 2> spectral(local_size, 1);
 
   auto offset = Partitioner<2>::local_offset(real);
   std::iota(real.begin(), real.end(), offset);
 
   FFTWMPIEngine().forward(real, spectral);
 
   auto gathered = Partitioner<2>::gather(spectral);
 
   if (mpi::rank() != 0)
     return;
 
   Grid<Real, 2> real_global({N0, N1}, 1);
   GridHermitian<Real, 2> solution({N0, N1 / 2 + 1}, 1);
 
   std::iota(real_global.begin(), real_global.end(), 0);
 
   FFTWEngine().forward(real_global, solution);
 
   // solution -= gathered;
   // Logger().get(LogLevel::info) << solution << '\n';
 
   // Increased error here because the iota input is bad:
   // because operations are not the same in parallel,
   // some parts of the output that should be close to zeros
   // have different values in serial and parallel cases
   ASSERT_TRUE(compare(gathered, solution, AreComplexEqual{1e-11}));
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFFTWMPIEngine, BackwardsTransform) {
   const std::ptrdiff_t N0 = 128, N1 = 128;
   auto local_size = Partitioner<2>::local_size({N0, N1 / 2 + 1});
 
   Grid<Real, 2> real({local_size[0], N1}, 1);
   GridHermitian<Real, 2> spectral(local_size, 1);
 
   real = 1.;
 
   FFTWMPIEngine engine;
 
   engine.forward(real, spectral);
   real = 0;
   engine.backward(real, spectral);
 
   auto gathered = Partitioner<2>::gather(real);
 
   if (mpi::rank() != 0)
     return;
 
   Grid<Real, 2> reference({N0, N1}, 1);
 
   reference = 1.;
 
   ASSERT_TRUE(compare(gathered, reference, AreFloatEqual()));
 }
 
 TEST(TestFFTWMPIEngine, ComponentsTransform) {
   const std::ptrdiff_t N0 = 10, N1 = 10;
   auto local_size = Partitioner<2>::local_size({N0, N1 / 2 + 1});
 
   Grid<Real, 2> real({local_size[0], N1}, 2);
   GridHermitian<Real, 2> spectral(local_size, 2);
 
   real = 1;
 
   FFTWMPIEngine().forward(real, spectral);
 
   auto gathered = Partitioner<2>::gather(spectral);
 
   if (mpi::rank() != 0)
     return;
 
   Grid<Real, 2> real_global({N0, N1}, 2);
   GridHermitian<Real, 2> solution({N0, N1 / 2 + 1}, 2);
 
   real_global = 1;
 
   FFTWEngine().forward(real_global, solution);
 
   ASSERT_TRUE(compare(gathered, solution, AreComplexEqual()));
 }
diff --git a/tests/test_rough_surface.cpp b/tests/test_rough_surface.cpp
index 564e17a..e7d452f 100644
--- a/tests/test_rough_surface.cpp
+++ b/tests/test_rough_surface.cpp
@@ -1,81 +1,82 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include "isopowerlaw.hh"
 #include "surface_generator_filter.hh"
 #include "polonsky_keer_rey.hh"
 #include "model_factory.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace tamaas;
 
 int main() {
   /// Surface parameters
   UInt grid_size = 512;
   const UInt k0 = 4, k1 = 4, k2 = 32;
   const Real hurst = 0.8;
 
   /// Surface generation (2D)
   SurfaceGeneratorFilter<2> sg;
   sg.setSizes({{grid_size, grid_size}});
   sg.setRandomSeed(0);
 
   auto iso = std::make_shared<Isopowerlaw<2>>();
   iso->setQ0(k0);
   iso->setQ1(k1);
   iso->setQ2(k2);
   iso->setHurst(hurst);
 
   sg.setSpectrum(iso);
 
   std::cout << "Building rough surface with properties\n"
 	    << "    Q0 = " << k0 << '\n'
 	    << "    Q1 = " << k1 << '\n'
 	    << "    Q2 = " << k2 << '\n'
 	    << "    Hurst = " << hurst << '\n'
 	    << "    size = " << grid_size << 'x' << grid_size << std::endl;
 
   /// Making surface
   GridBase<Real> & grid = sg.buildSurface();
 
   std::cout << "Creating model" << std::endl;
 
   /// Model initialization
   std::unique_ptr<Model> model{ModelFactory::createModel(
       model_type::basic_2d, {1., 1.}, {grid_size, grid_size})};
 
   Real load = 0.1;
   Real precision = 1e-12;
 
   std::cout << "Solving contact problem" << std::endl;
 
   /// Solve normal contact problem
   PolonskyKeerRey solver{*model, grid, precision, PolonskyKeerRey::pressure,
                          PolonskyKeerRey::pressure};
 
   solver.solve(load);
 
   std::cout << "Finished" << std::endl;
 
   return EXIT_SUCCESS;
 }
diff --git a/tests/test_static_types.cpp b/tests/test_static_types.cpp
index c7be321..a7f7068 100644
--- a/tests/test_static_types.cpp
+++ b/tests/test_static_types.cpp
@@ -1,106 +1,107 @@
 /*
  *  SPDX-License-Indentifier: AGPL-3.0-or-later
  *
  *  Copyright (©) 2016-2022 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *  Copyright (©) 2020-2022 Lucas Frérot
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Affero General Public License as published
  *  by the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Affero General Public License for more details.
  *
  *  You should have received a copy of the GNU Affero General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "static_types.hh"
 #include "test.hh"
 
 using namespace tamaas;
 
 /* -------------------------------------------------------------------------- */
 
 TEST(TestStaticTypes, GEMV) {
   Matrix<UInt, 3, 3> A({1, 2, 3, 4, 5, 6, 7, 8, 9});
   UInt b_[] = {1, 2, 3};
   VectorProxy<UInt, 3> b(b_);
 
   auto res = A * b;
   std::vector<UInt> solution = {14, 32, 50};
   ASSERT_TRUE(compare(res, solution)) << "Matrix multiplication fail";
 }
 
 TEST(TestStaticTypes, Dot) {
   UInt a_[] = {2, 3};
   UInt b_[] = {1, 5};
 
   VectorProxy<UInt, 2> a(a_[0]), b(b_[0]);
   ASSERT_EQ(a.dot(b), 17) << "Dot product fail";
 }
 
 TEST(TestStaticTypes, Norm) {
   Real a_[] = {3., 4.};
   VectorProxy<Real, 2> a(a_[0]);
   ASSERT_DOUBLE_EQ(a.l2norm(), 5) << "L2 norm fail";
 }
 
 TEST(TestStaticTypes, Symmetrization2D) {
   Matrix<Real, 2, 2> A({1, 2, 3, 4});
   Vector<Real, 3> Av({1, 4, std::sqrt(2) * 2.5});
   SymMatrix<Real, 2> As;
   As.symmetrize(A);
   ASSERT_TRUE(compare(Av, As, AreFloatEqual())) << "Symmetrization fail";
 
   Matrix<Real, 2, 2> B, Bref({1, 2.5, 2.5, 4});
   B.fromSymmetric(As);
   ASSERT_TRUE(compare(Bref, B, AreFloatEqual())) << "Dense construction fail";
 }
 
 TEST(TestStaticTypes, Symmetrization3D) {
   Matrix<Real, 3, 3> A({1, 2, 3, 4, 5, 6, 7, 8, 9});
   Vector<Real, 6> Av(
       {1, 5, 9, std::sqrt(2) * 7, std::sqrt(2) * 5, std::sqrt(2) * 3});
   SymMatrix<Real, 3> As;
   As.symmetrize(A);
   ASSERT_TRUE(compare(Av, As, AreFloatEqual())) << "Symmetrization fail";
 
   Matrix<Real, 3, 3> B, Bref({1, 3, 5, 3, 5, 7, 5, 7, 9});
   B.fromSymmetric(As);
   ASSERT_TRUE(compare(Bref, B, AreFloatEqual())) << "Dense construction fail";
 }
 
 TEST(TestStaticTypes, Invariants) {
   SymMatrix<Real, 3> Av(
       {1, 5, 9, std::sqrt(2) * 7, std::sqrt(2) * 5, std::sqrt(2) * 4});
   auto invar = invariants(Av);
   Matrix<Real, 3, 3> B;
   B.fromSymmetric(Av);
   auto B2 = B * B;
 
   Vector<Real, 3> sol;
   sol(0) = B.trace();
   sol(1) = 0.5 * (B.trace() * B.trace() - B2.trace());
   sol(2) = 7;
 
   ASSERT_TRUE(compare(invar, sol, AreFloatEqual{1e-14})) << "Invariants fail";
 }
 
 TEST(TestStaticTypes, Eigenvalues) {
   SymMatrix<Real, 3> Av({2, 3, 9, std::sqrt(2) * 4, 0, 0});
   auto eigen = eigenvalues(Av);
 
   // invariants
   Vector<Real, 3> sol;
   sol(0) = 1;
   sol(1) = 2;
   sol(2) = 11;
 
   ASSERT_TRUE(compare(eigen, sol, AreFloatEqual{1e-14}))
       << "Eigenvalues do not reproduce invariants";
 }