diff --git a/.arclint b/.arclint
index 73c2265..cae0567 100644
--- a/.arclint
+++ b/.arclint
@@ -1,18 +1,24 @@
 {
     "linters": {
 	"python": {
             "type": "flake8",
             "include": [ "(\\.py$)", "(^hbm$)" ],
             "exclude": ["(^third-party/)", "(legacy/)"],
 	    "severity.rules": {
 		"(^E)": "error",
 		"(^W)": "warning",
 		"(^F)": "advice"
 	    }
         },
 
+        "format": {
+            "type": "clang-format",
+            "include": [ "(\\.cc$)", "(\\.hh$)" ],
+            "exclude": "(^third-party/)"
+        },
+
         "merges": {
             "type": "merge-conflict"
         }
     }
 }
diff --git a/src/core/array.hh b/src/core/array.hh
index 7d48317..727e24a 100644
--- a/src/core/array.hh
+++ b/src/core/array.hh
@@ -1,160 +1,160 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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 "tamaas.hh"
 #include <thrust/fill.h>
 #include <thrust/copy.h>
 #include <memory>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @brief Generic storage class with wrapping capacities
  */
 template <typename T>
 class Array final {
 public:
   /// 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(v._data, v._data + v._size, this->_data);
   }
   /// Move constructor (transfers data ownership)
-  Array(Array&& v) : Array() {
+  Array(Array&& v) noexcept : Array() {
     _data = std::exchange(v._data, nullptr);
     _size = std::exchange(v._size, 0);
     wrapped = std::exchange(v.wrapped, false);
   }
   /// Wrap array on data
   Array(T* data, UInt size) : Array() { this->wrapMemory(data, size); }
   /// Destructor
   ~Array() {
-    if (wrapped == false)
+    if (not wrapped)
       _alloc.deallocate(_data, _size);
   }
 
 public:
   /// Copy operator
   Array& operator=(const Array& v) {
     this->wrapped = false;
     if (v.size() != this->size())
       this->resize(v.size());
     thrust::copy(v._data, v._data + _size, _data);
     return *this;
   }
 
   /// Move operator
-  Array& operator=(Array&& v) {
+  Array& operator=(Array&& v) noexcept {
     if (this != &v) {
-      if (!wrapped)
+      if (not wrapped)
         _alloc.deallocate(_data, _size);
       _data = std::exchange(v._data, nullptr);
       _size = std::exchange(v._size, 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) {
     this->_data = data;
     this->_size = size;
     this->wrapped = true;
   }
 
   /// 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 == true)
+    if (wrapped)
       TAMAAS_EXCEPTION("cannot resize wrapped array");
 
     // Erase array
     if (size == 0) {
       _alloc.deallocate(_data, _size);
       this->_data = nullptr;
       this->_size = 0;
       return;
     }
 
     // Do nothing
     if (size == this->_size)
       return;
 
     // Allocate new data
     _alloc.deallocate(_data, _size);
 
     this->_data = _alloc.allocate(size);
     this->_size = 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;
   bool wrapped = false;
   DEFAULT_ALLOCATOR(T) _alloc = DEFAULT_ALLOCATOR(T)();
 };
 
 }  // namespace tamaas
 /* -------------------------------------------------------------------------- */
 #endif /* __ARRAY__HH__ */
diff --git a/src/core/fftw_allocator.hh b/src/core/fftw_allocator.hh
index 92e6554..135fa90 100644
--- a/src/core/fftw_allocator.hh
+++ b/src/core/fftw_allocator.hh
@@ -1,50 +1,52 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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
-  T* allocate(std::size_t n) {
+  T* allocate(std::size_t n) noexcept {
     T* p = nullptr;
     p = (T*)fftw_malloc(sizeof(T) * n);
     return p;
   }
 
   /// Free memory
-  void deallocate(T* p, __attribute__((unused)) std::size_t n) { fftw_free(p); }
+  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/grid.cpp b/src/core/grid.cpp
index 74940ae..9224743 100644
--- a/src/core/grid.cpp
+++ b/src/core/grid.cpp
@@ -1,121 +1,122 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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)
-    : GridBase<T>(o), n(std::move(o.n)), strides(std::move(o.strides)) {}
+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.rbegin() + 2);
   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 8eb56bf..bfa30c3 100644
--- a/src/core/grid.hh
+++ b/src/core/grid.hh
@@ -1,222 +1,222 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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);
+  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
   virtual 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 (not const input, otherwise gcc is confused)
   Grid& operator=(Grid& other);
   // = operator (move)
-  Grid& operator=(Grid&& other);
+  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);
+  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 9cf1d59..b0398d6 100644
--- a/src/core/grid_base.hh
+++ b/src/core/grid_base.hh
@@ -1,331 +1,331 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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 "tamaas.hh"
 #include "static_types.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)
+  GridBase(GridBase&& o) noexcept
       : data(std::move(o.data)),
         nb_components(std::exchange(o.nb_components, 1)) {}
 
   /// Destructor
   virtual ~GridBase() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Iterator class */
   /* ------------------------------------------------------------------------ */
 public:
   using iterator = iterator_::iterator<T>;
   using const_iterator = iterator_::iterator<const T>;
   using value_type = T;
   using reference = value_type&;
 
 public:
   /// 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 number of points
   UInt getNbPoints() const {
     return this->dataSize() / this->getNbComponents();
   }
   /// Set components
   void uniformSetComponents(const GridBase<T>& vec);
   /// Resize
   void resize(UInt size) {
     this->data.resize(size);
     this->data.assign(size, T(0.));
   }
 
   /* ------------------------------------------------------------------------ */
   /* 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>(dataSize()); }
   T var() const;
 
   /* ------------------------------------------------------------------------ */
   /* Move/Copy */
   /* ------------------------------------------------------------------------ */
 
 public:
   GridBase& operator=(const GridBase& o) {
     this->copy(o);
     return *this;
   }
 
   GridBase& operator=(GridBase& o) {
     this->copy(o);
     return *this;
   }
 
-  GridBase& operator=(GridBase&& o) {
+  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) {
+  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 / (dataSize() - 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.hh b/src/core/grid_hermitian.hh
index 41e947b..b914a05 100644
--- a/src/core/grid_hermitian.hh
+++ b/src/core/grid_hermitian.hh
@@ -1,163 +1,163 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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 <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) = 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;
   }
 
   static std::vector<UInt>
   hermitianDimensions(std::vector<UInt> n) {
     TAMAAS_ASSERT(n.size() == dim,
                   "Requested size dimension does not match class dimension");
     n[dim - 1] /= 2;
     n[dim - 1] += 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;
   }
 
   else
     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;
   }
 
   else
     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 c928c76..b18c0cf 100644
--- a/src/core/grid_tmpl.hh
+++ b/src/core/grid_tmpl.hh
@@ -1,159 +1,159 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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) {
   this->copy(other);
   return *this;
 }
 
 template <typename T, UInt dim>
-Grid<T, dim>& Grid<T, dim>::operator=(Grid<T, dim>&& other) {
+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) {
+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 5589ecd..cd34ac4 100644
--- a/src/core/grid_view.hh
+++ b/src/core/grid_view.hh
@@ -1,159 +1,159 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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)
+  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(); }
 
   /// 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, 0),
             grid->sizes().end(), this->n.begin() + std::max(-dim_offset, 0));
   std::copy(grid->getStrides().begin() + std::max(dim_offset, 0),
             grid->getStrides().end(),
             this->strides.begin() + std::max(-dim_offset, 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, this->computeSize());
 }
 
 /* -------------------------------------------------------------------------- */
 
 }  // namespace tamaas
 
 #endif  // __GRID_VIEW_HH__
diff --git a/src/core/iterator.hh b/src/core/iterator.hh
index bbb8359..4d3d0c0 100644
--- a/src/core/iterator.hh
+++ b/src/core/iterator.hh
@@ -1,187 +1,187 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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)
+  __device__ __host__ iterator(iterator&& o) noexcept
       : data(std::exchange(o.data, nullptr)), step(std::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(std::exchange(o.data, nullptr)), step(std::exchange(o.step, 0)) {}
 
   // assign
   iterator& operator=(const iterator& o) {
     data = o.data;
     step = o.step;
     return *this;
   }
 
   // move
-  iterator& operator=(iterator&& o) {
+  iterator& operator=(iterator&& o) noexcept {
     data = std::exchange(o.data, nullptr);
     step = std::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/surface.hh b/src/core/surface.hh
index 3affae4..d2b76af 100644
--- a/src/core/surface.hh
+++ b/src/core/surface.hh
@@ -1,117 +1,117 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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_HH__
 #define __SURFACE_HH__
 /* -------------------------------------------------------------------------- */
 #include <complex>
 #include <iostream>
 #include <limits>
 #include <string>
 /* -------------------------------------------------------------------------- */
 #include "grid.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace tamaas {
 
 /**
  * @deprecated should use Grid class instead
  * @brief Square 2D surface class
  */
 template <typename T>
 class Surface : public Grid<T, 2> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-  Surface() : Grid<T, 2>() {}
+  using Grid<T, 2>::Grid;
 
   Surface(UInt a, Real L) : Grid<T, 2>() {
     setGridSize(a);
     setL(L);
   }
 
-  ~Surface() override = default;
-
   Surface(const Surface& o) : Grid<T, 2>(o) {}
-  Surface(Surface&& o) : Grid<T, 2>(std::forward<Surface>(o)) {}
+  Surface(Surface&& o) noexcept : Grid<T, 2>(std::move(o)) {}
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   //! set the grid size
   void setGridSize(UInt n) { this->resize({n, n}); }
   //! get lateral number of discretization points
   inline UInt size() const { return this->n[0]; };
   //! get the lateral size of the sample
   inline Real getL() const { return 1.; };
   //! get the lateral size of the sample
   inline void setL(Real) {}
 
   Surface& operator=(T val) {
     Grid<T, 2>::operator=(val);
     return *this;
   }
+
   Surface& operator=(const Surface& o) {
     Grid<T, 2>::operator=(o);
     return *this;
   }
-  Surface& operator=(Surface&& o) {
-    Grid<T, 2>::operator=(std::forward<Surface>(o));
+
+  Surface& operator=(Surface&& o) noexcept {
+    Grid<T, 2>::operator=(std::move(o));
     return *this;
   }
 
   //! Write VTU file that is a set of points
   void dumpToParaview(std::string filename) const;
   //! create a new surface with linear interpolated points
   void expandByLinearInterpolation();
   //! create a new surface with linear interpolated points
   void expandByShannonInterpolation(int factor);
   //! create a new surface with mirroring
   void expandByMirroring();
   //! create a new surface with mirroring
   void expandByPuttingZeros();
   //! contract the surface by ignoring extra data
   void contractByIgnoringMidPoints();
   //! contract the surface by taking left bottom part of it
   void contractByTakingSubRegion();
   // recenter the heights to zero value
   void recenterHeights();
   // set all the members of the map to a given value
   static void generateWhiteNoiseSurface(Surface<Real>& surface,
                                         long random_seed);
   virtual const Surface<T>& getWrappedNumpy() { return *this; };
 };
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas
 
 #include "surface_complex.hh"
 
 #endif /* __SURFACE_HH__ */
diff --git a/src/model/adhesion_functional.hh b/src/model/adhesion_functional.hh
index 3477cef..6c16d41 100644
--- a/src/model/adhesion_functional.hh
+++ b/src/model/adhesion_functional.hh
@@ -1,103 +1,103 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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)
       : Functional(), 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 = 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/model.cpp b/src/model/model.cpp
index 9df15c5..ad27ffd 100644
--- a/src/model/model.cpp
+++ b/src/model/model.cpp
@@ -1,163 +1,163 @@
 /**
  *  @file
  *  @section LICENSE
  *
  *  Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
  *  Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  *  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 {
 /* -------------------------------------------------------------------------- */
 
 Model::Model(std::vector<Real> system_size, std::vector<UInt> discretization)
     : system_size(std::move(system_size)),
       discretization(std::move(discretization)) {}
 
 /* -------------------------------------------------------------------------- */
 
 Model::~Model() = default;
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setElasticity(Real E, Real nu) {
   this->E = E;
   this->nu = nu;
   updateOperators();
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real Model::getHertzModulus() const { return E / (1 - nu * nu); }
 
 /* -------------------------------------------------------------------------- */
 
 GridBase<Real>& Model::getTraction() { return getField("traction"); }
 
 const GridBase<Real>& Model::getTraction() const {
   return getField("traction");
 }
 
 /* -------------------------------------------------------------------------- */
 
 GridBase<Real>& Model::getDisplacement() { return getField("displacement"); }
 
 const GridBase<Real>& Model::getDisplacement() const {
   return getField("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(getField("traction"), getField("displacement"));
 }
 
 void Model::solveDirichlet() {
   engine->registerDirichlet();
   engine->solveDirichlet(getField("displacement"), getField("traction"));
 }
 
 /* -------------------------------------------------------------------------- */
 IntegralOperator* Model::getIntegralOperator(const std::string& name) {
   return operators[name].get();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::updateOperators() {
   for (auto& op : operators)
     op.second->updateFromModel();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumper(std::shared_ptr<ModelDumper> dumper) {
-  this->dumpers.push_back(dumper);
+  this->dumpers.push_back(std::move(dumper));
 }
 
 void Model::dump() const {
   for (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;
 }
 
 /* -------------------------------------------------------------------------- */
 std::ostream& operator<<(std::ostream& o, const Model& _this) {
   o << "Model<" << _this.getType() << "> (E = " << _this.getYoungModulus()
     << ", nu = " << _this.getPoissonRatio() << ")\n";
 
   // Printing domain size
   o << "  - domain = [";
   std::for_each(_this.getSystemSize().begin(), _this.getSystemSize().end() - 1,
                 [&o](const Real& x) { o << x << ", "; });
   o << _this.getSystemSize().back() << "]\n";
 
   // Printing discretization
   o << "  - discretization = [";
   std::for_each(_this.getDiscretization().begin(),
                 _this.getDiscretization().end() - 1,
                 [&o](const UInt& x) { o << x << ", "; });
   o << _this.getDiscretization().back() << "]";
 
   return o;
 }
 
 /* -------------------------------------------------------------------------- */
 }  // namespace tamaas