diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6c36b3ea9fbd6526c7a00e78baf85afffb486480..25b2c725a146c1398fd461ddda638feb62b1b48b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -269,8 +269,8 @@ endif()
 # Rang (colors? Useless thus necessary!)
 include_directories(${PUGS_SOURCE_DIR}/packages/rang/include)
 
-# CLI11 (set as SYSTEM for static analysis)
-include_directories(SYSTEM ${PUGS_SOURCE_DIR}/packages/CLI11/include)
+# CLI11
+include_directories(${PUGS_SOURCE_DIR}/packages/CLI11/include)
 
 # PEGTL
 include_directories(${PUGS_SOURCE_DIR}/packages/PEGTL/include/tao)
diff --git a/src/algebra/TinyMatrix.hpp b/src/algebra/TinyMatrix.hpp
index 6cff7777f522c348c31ebf5eed9460f6adbfcd63..3ef5e180710d90e0b62e0cf8f8d222cb3a84ca14 100644
--- a/src/algebra/TinyMatrix.hpp
+++ b/src/algebra/TinyMatrix.hpp
@@ -22,7 +22,7 @@ class TinyMatrix
 
   PUGS_FORCEINLINE
   constexpr size_t
-  _index(const size_t& i, const size_t& j) const noexcept   // LCOV_EXCL_LINE (due to forced inline)
+  _index(size_t i, size_t j) const noexcept   // LCOV_EXCL_LINE (due to forced inline)
   {
     return i * N + j;
   }
@@ -215,7 +215,7 @@ class TinyMatrix
 
   PUGS_INLINE
   constexpr T&
-  operator()(const size_t& i, const size_t& j) noexcept(NO_ASSERT)
+  operator()(size_t i, size_t j) noexcept(NO_ASSERT)
   {
     Assert((i < N) and (j < N));
     return m_values[_index(i, j)];
@@ -223,15 +223,14 @@ class TinyMatrix
 
   PUGS_INLINE
   constexpr const T&
-  operator()(const size_t& i, const size_t& j) const noexcept(NO_ASSERT)
+  operator()(size_t i, size_t j) const noexcept(NO_ASSERT)
   {
     Assert((i < N) and (j < N));
     return m_values[_index(i, j)];
   }
 
   PUGS_INLINE
-  constexpr TinyMatrix&
-  operator=(const ZeroType&) noexcept
+  constexpr TinyMatrix& operator=(ZeroType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot assign 'zero' value for non-arithmetic types");
     for (size_t i = 0; i < N * N; ++i) {
@@ -241,8 +240,7 @@ class TinyMatrix
   }
 
   PUGS_INLINE
-  constexpr TinyMatrix&
-  operator=(const IdentityType&) noexcept
+  constexpr TinyMatrix& operator=(IdentityType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot assign 'identity' value for non-arithmetic types");
     for (size_t i = 0; i < N; ++i) {
@@ -272,7 +270,7 @@ class TinyMatrix
   constexpr TinyMatrix() noexcept {}
 
   PUGS_INLINE
-  constexpr TinyMatrix(const ZeroType&) noexcept
+  constexpr TinyMatrix(ZeroType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot construct from 'zero' value "
                                            "for non-arithmetic types");
@@ -282,7 +280,7 @@ class TinyMatrix
   }
 
   PUGS_INLINE
-  constexpr TinyMatrix(const IdentityType&) noexcept
+  constexpr TinyMatrix(IdentityType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot construct from 'identity' "
                                            "value for non-arithmetic types");
@@ -388,7 +386,7 @@ det(const TinyMatrix<3, T>& A)
 
 template <size_t N, typename T>
 PUGS_INLINE constexpr TinyMatrix<N - 1, T>
-getMinor(const TinyMatrix<N, T>& A, const size_t& I, const size_t& J)
+getMinor(const TinyMatrix<N, T>& A, size_t I, size_t J)
 {
   static_assert(N >= 2, "minor calculation requires at least 2x2 matrices");
   Assert((I < N) and (J < N));
@@ -428,7 +426,7 @@ inverse(const TinyMatrix<1, T>& A)
 
 template <size_t N, typename T>
 PUGS_INLINE constexpr T
-cofactor(const TinyMatrix<N, T>& A, const size_t& i, const size_t& j)
+cofactor(const TinyMatrix<N, T>& A, size_t i, size_t j)
 {
   static_assert(std::is_arithmetic<T>::value, "cofactor is not defined for non-arithmetic types");
   const T sign = ((i + j) % 2) ? -1 : 1;
diff --git a/src/algebra/TinyVector.hpp b/src/algebra/TinyVector.hpp
index a999ec7bcee342dd252d85fd85be8d1364308216..5f5e8a7eb109ba293e13eb9a153918c126816923 100644
--- a/src/algebra/TinyVector.hpp
+++ b/src/algebra/TinyVector.hpp
@@ -185,22 +185,21 @@ class TinyVector
   }
 
   PUGS_INLINE
-  constexpr T& operator[](const size_t& i) noexcept(NO_ASSERT)
+  constexpr T& operator[](size_t i) noexcept(NO_ASSERT)
   {
     Assert(i < N);
     return m_values[i];
   }
 
   PUGS_INLINE
-  constexpr const T& operator[](const size_t& i) const noexcept(NO_ASSERT)
+  constexpr const T& operator[](size_t i) const noexcept(NO_ASSERT)
   {
     Assert(i < N);
     return m_values[i];
   }
 
   PUGS_INLINE
-  constexpr TinyVector&
-  operator=(const ZeroType&) noexcept
+  constexpr TinyVector& operator=(ZeroType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot assign 'zero' value for non-arithmetic types");
     for (size_t i = 0; i < N; ++i) {
@@ -222,13 +221,13 @@ class TinyVector
     this->_unpackVariadicInput(t, std::forward<Args>(args)...);
   }
 
-  // One does not use the '=default' constructor to avoid (unexpected)
-  // performances issues
+  // One does not use the '=default' constructor to avoid
+  // (zero-initialization) performances issues
   PUGS_INLINE
   constexpr TinyVector() noexcept {}
 
   PUGS_INLINE
-  constexpr TinyVector(const ZeroType&) noexcept
+  constexpr TinyVector(ZeroType) noexcept
   {
     static_assert(std::is_arithmetic<T>(), "Cannot construct from 'zero' value "
                                            "for non-arithmetic types");
diff --git a/src/algebra/Vector.hpp b/src/algebra/Vector.hpp
index ac48d969fc55432d3cd8fe180997af09ccee84d0..efe64b41a8940be9fadf7066dd5dc27bff90a633 100644
--- a/src/algebra/Vector.hpp
+++ b/src/algebra/Vector.hpp
@@ -75,7 +75,7 @@ class Vector   // LCOV_EXCL_LINE
   operator*=(const DataType2& a)
   {
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] *= a; });
+      this->size(), PUGS_LAMBDA(index_type i) { m_values[i] *= a; });
     return *this;
   }
 
@@ -86,7 +86,7 @@ class Vector   // LCOV_EXCL_LINE
     Assert(this->size() == y.size());
 
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] -= y[i]; });
+      this->size(), PUGS_LAMBDA(index_type i) { m_values[i] -= y[i]; });
 
     return *this;
   }
@@ -98,7 +98,7 @@ class Vector   // LCOV_EXCL_LINE
     Assert(this->size() == y.size());
 
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] += y[i]; });
+      this->size(), PUGS_LAMBDA(index_type i) { m_values[i] += y[i]; });
 
     return *this;
   }
@@ -111,7 +111,7 @@ class Vector   // LCOV_EXCL_LINE
     Vector<std::remove_const_t<DataType>> sum{y.size()};
 
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { sum.m_values[i] = m_values[i] + y[i]; });
+      this->size(), PUGS_LAMBDA(index_type i) { sum.m_values[i] = m_values[i] + y[i]; });
 
     return sum;
   }
@@ -124,13 +124,13 @@ class Vector   // LCOV_EXCL_LINE
     Vector<std::remove_const_t<DataType>> sum{y.size()};
 
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { sum.m_values[i] = m_values[i] - y[i]; });
+      this->size(), PUGS_LAMBDA(index_type i) { sum.m_values[i] = m_values[i] - y[i]; });
 
     return sum;
   }
 
   PUGS_INLINE
-  DataType& operator[](const index_type& i) const noexcept(NO_ASSERT)
+  DataType& operator[](index_type i) const noexcept(NO_ASSERT)
   {
     return m_values[i];
   }
@@ -180,7 +180,7 @@ class Vector   // LCOV_EXCL_LINE
 
   Vector(Vector&&) = default;
 
-  Vector(const size_t& size) : m_values{size} {}
+  Vector(size_t size) : m_values{size} {}
   ~Vector() = default;
 };
 
diff --git a/src/mesh/CellType.hpp b/src/mesh/CellType.hpp
index d0f6986d63a97677662ae91d980e9af02b114347..f0f214a60d9e9fb214e221b7dac1516b9c69b778 100644
--- a/src/mesh/CellType.hpp
+++ b/src/mesh/CellType.hpp
@@ -20,7 +20,7 @@ enum class CellType : unsigned short
 
 PUGS_INLINE
 std::string_view
-name(const CellType& cell_type)
+name(CellType cell_type)
 {
   switch (cell_type) {
   case CellType::Line:
diff --git a/src/mesh/Connectivity.cpp b/src/mesh/Connectivity.cpp
index dc51fe75a6cb773e99d59e235b137c7dd98c1164..a011948482bc8a9b1b562da6625a11a77e6a5b9b 100644
--- a/src/mesh/Connectivity.cpp
+++ b/src/mesh/Connectivity.cpp
@@ -27,7 +27,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
   {
     WeakCellValue<CellType> cell_type(*this);
     parallel_for(
-      this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_type[j] = descriptor.cell_type_vector[j]; });
+      this->numberOfCells(), PUGS_LAMBDA(CellId j) { cell_type[j] = descriptor.cell_type_vector[j]; });
     m_cell_type = cell_type;
   }
 
@@ -47,7 +47,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     WeakCellValue<int> cell_global_index(*this);
     int first_index = 0;
     parallel_for(
-      this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_global_index[j] = first_index + j; });
+      this->numberOfCells(), PUGS_LAMBDA(CellId j) { cell_global_index[j] = first_index + j; });
     m_cell_global_index = cell_global_index;
   }
 
@@ -61,7 +61,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     const int rank = parallel::rank();
     WeakCellValue<bool> cell_is_owned(*this);
     parallel_for(
-      this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_is_owned[j] = (m_cell_owner[j] == rank); });
+      this->numberOfCells(), PUGS_LAMBDA(CellId j) { cell_is_owned[j] = (m_cell_owner[j] == rank); });
     m_cell_is_owned = cell_is_owned;
   }
 
@@ -75,7 +75,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     const int rank = parallel::rank();
     WeakNodeValue<bool> node_is_owned(*this);
     parallel_for(
-      this->numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { node_is_owned[r] = (m_node_owner[r] == rank); });
+      this->numberOfNodes(), PUGS_LAMBDA(NodeId r) { node_is_owned[r] = (m_node_owner[r] == rank); });
     m_node_is_owned = node_is_owned;
   }
 
@@ -114,7 +114,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
       const int rank = parallel::rank();
       WeakFaceValue<bool> face_is_owned(*this);
       parallel_for(
-        this->numberOfFaces(), PUGS_LAMBDA(const FaceId& l) { face_is_owned[l] = (m_face_owner[l] == rank); });
+        this->numberOfFaces(), PUGS_LAMBDA(FaceId l) { face_is_owned[l] = (m_face_owner[l] == rank); });
       m_face_is_owned = face_is_owned;
     }
 
@@ -154,7 +154,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
         const int rank = parallel::rank();
         WeakEdgeValue<bool> edge_is_owned(*this);
         parallel_for(
-          this->numberOfEdges(), PUGS_LAMBDA(const EdgeId& e) { edge_is_owned[e] = (m_edge_owner[e] == rank); });
+          this->numberOfEdges(), PUGS_LAMBDA(EdgeId e) { edge_is_owned[e] = (m_edge_owner[e] == rank); });
         m_edge_is_owned = edge_is_owned;
       }
 
diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp
index 3c319b053eb40a569c660d4c35a0b1235dfa768b..c75fa1f80d50e11e6ddab6dc9b60df2ece62859a 100644
--- a/src/mesh/Connectivity.hpp
+++ b/src/mesh/Connectivity.hpp
@@ -286,7 +286,7 @@ class Connectivity final : public IConnectivity
 
   PUGS_INLINE
   const bool&
-  isConnectivityMatrixBuilt(const ItemType& item_type_0, const ItemType& item_type_1) const
+  isConnectivityMatrixBuilt(ItemType item_type_0, ItemType item_type_1) const
   {
     const ConnectivityMatrix& connectivity_matrix = m_item_to_item_matrix[itemTId(item_type_0)][itemTId(item_type_1)];
     return connectivity_matrix.isBuilt();
@@ -523,7 +523,7 @@ class Connectivity final : public IConnectivity
 
   template <ItemType item_type>
   const RefItemList<item_type>&
-  refItemList(const size_t& i) const
+  refItemList(size_t i) const
   {
     if constexpr (item_type == ItemType::cell) {
       return m_ref_cell_list_vector[i];
@@ -647,7 +647,7 @@ class Connectivity final : public IConnectivity
 
       WeakCellValue<double> inv_cell_nb_nodes(*this);
       parallel_for(
-        this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+        this->numberOfCells(), PUGS_LAMBDA(CellId j) {
           const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
           inv_cell_nb_nodes[j]   = 1. / cell_nodes.length;
         });
diff --git a/src/mesh/ConnectivityComputer.cpp b/src/mesh/ConnectivityComputer.cpp
index a47b491160bb3c27a935925083ba0fb230bfc6c2..f74316c566dc69992eddc7bf5dfabdf537be5195 100644
--- a/src/mesh/ConnectivityComputer.cpp
+++ b/src/mesh/ConnectivityComputer.cpp
@@ -9,8 +9,8 @@
 template <typename ConnectivityType>
 PUGS_INLINE ConnectivityMatrix
 ConnectivityComputer::computeConnectivityMatrix(const ConnectivityType& connectivity,
-                                                const ItemType& item_type,
-                                                const ItemType& child_item_type) const
+                                                ItemType item_type,
+                                                ItemType child_item_type) const
 {
   ConnectivityMatrix item_to_child_item_matrix;
   if (connectivity.isConnectivityMatrixBuilt(child_item_type, item_type)) {
@@ -29,16 +29,16 @@ ConnectivityComputer::computeConnectivityMatrix(const ConnectivityType& connecti
 }
 
 template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity1D&,
-                                                                            const ItemType&,
-                                                                            const ItemType&) const;
+                                                                            ItemType,
+                                                                            ItemType) const;
 
 template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity2D&,
-                                                                            const ItemType&,
-                                                                            const ItemType&) const;
+                                                                            ItemType,
+                                                                            ItemType) const;
 
 template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity3D&,
-                                                                            const ItemType&,
-                                                                            const ItemType&) const;
+                                                                            ItemType,
+                                                                            ItemType) const;
 
 ConnectivityMatrix
 ConnectivityComputer::_computeInverse(const ConnectivityMatrix& item_to_child_matrix) const
diff --git a/src/mesh/ConnectivityComputer.hpp b/src/mesh/ConnectivityComputer.hpp
index c6e2a569bc00e0c620224ee9ce9037e4085824e7..a4f843e218107b49a6913e3f9028bf034df7c63f 100644
--- a/src/mesh/ConnectivityComputer.hpp
+++ b/src/mesh/ConnectivityComputer.hpp
@@ -12,8 +12,8 @@ class ConnectivityComputer
  public:
   template <typename ConnectivityType>
   ConnectivityMatrix computeConnectivityMatrix(const ConnectivityType& connectivity,
-                                               const ItemType& item_type,
-                                               const ItemType& child_item_type) const;
+                                               ItemType item_type,
+                                               ItemType child_item_type) const;
 
   template <typename ItemOfItem, typename ConnectivityType>
   WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed> computeLocalItemNumberInChildItem(
diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index ebba8dbe16312c61695f378291d79bfaf82d06d3..82bf2a2e006a13d0806b2d88b1dc54715a0cc116 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -372,7 +372,7 @@ ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc()
     Array<int> send_item_number(item_list_to_send_by_proc[i_rank].size());
     const Array<const ItemId> send_item_id = item_list_to_send_by_proc[i_rank];
     parallel_for(
-      send_item_number.size(), PUGS_LAMBDA(const size_t& j) { send_item_number[j] = item_number[send_item_id[j]]; });
+      send_item_number.size(), PUGS_LAMBDA(size_t j) { send_item_number[j] = item_number[send_item_id[j]]; });
     send_item_number_by_proc[i_rank] = send_item_number;
   }
 
@@ -514,7 +514,7 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
           Array<block_type> send_item_refs(nb_item_to_send_by_proc[i_rank]);
           const Array<const ItemId> send_item_id = send_item_id_by_proc[i_rank];
           parallel_for(
-            send_item_id.size(), PUGS_LAMBDA(const size_t& l) {
+            send_item_id.size(), PUGS_LAMBDA(size_t l) {
               const ItemId& item_id = send_item_id[l];
               send_item_refs[l]     = item_references[item_id];
             });
diff --git a/src/mesh/ConnectivityMatrix.hpp b/src/mesh/ConnectivityMatrix.hpp
index bef24bde58b5300d2285a7929bb06e45df00de1b..705dd8a3c6ff035e9c6a0be3cb4eac9cc77a70d2 100644
--- a/src/mesh/ConnectivityMatrix.hpp
+++ b/src/mesh/ConnectivityMatrix.hpp
@@ -53,14 +53,14 @@ class ConnectivityMatrix
 
   PUGS_INLINE
   auto
-  rowConst(const size_t& j) const
+  rowConst(size_t j) const
   {
     return m_host_matrix.rowConst(j);
   }
 
   PUGS_INLINE
   const auto&
-  rowMap(const size_t& j) const
+  rowMap(size_t j) const
   {
     return m_host_matrix.row_map[j];
   }
diff --git a/src/mesh/GmshReader.hpp b/src/mesh/GmshReader.hpp
index 3501cafdf8c735ab73edf808ca7c886ec572ae34..2b95822863c4ce87395ffc3173ca5934287fd40e 100644
--- a/src/mesh/GmshReader.hpp
+++ b/src/mesh/GmshReader.hpp
@@ -61,7 +61,7 @@ class GmshReader
 
     PhysicalRefId& operator=(const PhysicalRefId&) = default;
     PhysicalRefId& operator=(PhysicalRefId&&) = default;
-    PhysicalRefId(const int& dimension, const RefId& ref_id) : m_dimension(dimension), m_ref_id(ref_id)
+    PhysicalRefId(int dimension, const RefId& ref_id) : m_dimension(dimension), m_ref_id(ref_id)
     {
       ;
     }
diff --git a/src/mesh/IConnectivity.hpp b/src/mesh/IConnectivity.hpp
index 76a85e0e3d8aae38ba97234395452cbba645db60..27be707cbcc4976b17e9db1e7bf6f37195c9d63a 100644
--- a/src/mesh/IConnectivity.hpp
+++ b/src/mesh/IConnectivity.hpp
@@ -33,6 +33,7 @@ class IConnectivity : public std::enable_shared_from_this<IConnectivity>
   size_t numberOf() const = delete;
 
   IConnectivity()                     = default;
+  IConnectivity(IConnectivity&&)      = delete;
   IConnectivity(const IConnectivity&) = delete;
   ~IConnectivity()                    = default;
 };
diff --git a/src/mesh/ItemId.hpp b/src/mesh/ItemId.hpp
index 8863c1a2867773344b8ed6907ebc6786bff0a7f6..c52958f8bd8d48537c8a99666169d0fd1968c003 100644
--- a/src/mesh/ItemId.hpp
+++ b/src/mesh/ItemId.hpp
@@ -40,7 +40,7 @@ class ItemIdT
 
   PUGS_INLINE
   constexpr ItemIdT&
-  operator=(const base_type& id)
+  operator=(base_type id)
   {
     m_id = id;
     return *this;
@@ -53,7 +53,7 @@ class ItemIdT
   constexpr ItemIdT& operator=(ItemIdT&&) = default;
 
   PUGS_INLINE
-  constexpr ItemIdT(const base_type& id) : m_id{id} {}
+  constexpr ItemIdT(base_type id) : m_id{id} {}
 
   PUGS_INLINE
   constexpr ItemIdT(const ItemIdT&) = default;
diff --git a/src/mesh/ItemToItemMatrix.hpp b/src/mesh/ItemToItemMatrix.hpp
index a3fc307e03bf928203510514bb2f33cafd3d453c..e8d7071af5ae2c09b60c10478560087f5b2bdc86 100644
--- a/src/mesh/ItemToItemMatrix.hpp
+++ b/src/mesh/ItemToItemMatrix.hpp
@@ -29,7 +29,7 @@ class ItemToItemMatrix
     }
 
     PUGS_INLINE
-    TargetItemId operator[](const size_t& j) const
+    TargetItemId operator[](size_t j) const
     {
       return m_row(j);
     }
diff --git a/src/mesh/ItemType.hpp b/src/mesh/ItemType.hpp
index 21aebfc5d46b3d9c29712dfb54795826f076c9a3..a63c5e76a31de169f84e2e89eda36aac540b19d3 100644
--- a/src/mesh/ItemType.hpp
+++ b/src/mesh/ItemType.hpp
@@ -17,7 +17,7 @@ enum class ItemType
 
 PUGS_INLINE
 constexpr std::string_view
-itemName(const ItemType& item_type)
+itemName(ItemType item_type)
 {
   std::string_view name;
   switch (item_type) {
@@ -51,7 +51,7 @@ struct ItemTypeId<1>
 {
   PUGS_INLINE
   static constexpr size_t
-  itemTId(const ItemType& item_type)
+  itemTId(ItemType item_type)
   {
     size_t i = std::numeric_limits<size_t>::max();
     switch (item_type) {
@@ -76,7 +76,7 @@ struct ItemTypeId<2>
 {
   PUGS_INLINE
   static constexpr size_t
-  itemTId(const ItemType& item_type)
+  itemTId(ItemType item_type)
   {
     size_t i = std::numeric_limits<size_t>::max();
     switch (item_type) {
@@ -104,7 +104,7 @@ struct ItemTypeId<3>
 {
   PUGS_INLINE
   static constexpr size_t
-  itemTId(const ItemType& item_type)
+  itemTId(ItemType item_type)
   {
     size_t i = std::numeric_limits<size_t>::max();
     switch (item_type) {
diff --git a/src/mesh/Mesh.hpp b/src/mesh/Mesh.hpp
index afafc7a2115d201055c93e0952c3a1e5216e05c2..92ec018e9033d87b751b71e3b67d33888356878e 100644
--- a/src/mesh/Mesh.hpp
+++ b/src/mesh/Mesh.hpp
@@ -10,8 +10,14 @@
 
 struct IMesh
 {
+ public:
   virtual size_t dimension() const = 0;
-  ~IMesh()                         = default;
+
+  IMesh(const IMesh&) = delete;
+  IMesh(IMesh&&)      = delete;
+
+  IMesh()  = default;
+  ~IMesh() = default;
 };
 
 template <typename ConnectivityType>
diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp
index 2a1406c447f4eeb2d8e2b40b0ae3f229650d107e..1647abc0b1fe9f8e29d3a5a6a230548fc8f799b9 100644
--- a/src/mesh/MeshData.hpp
+++ b/src/mesh/MeshData.hpp
@@ -41,7 +41,7 @@ class MeshData
 
       CellValue<Rd> xj(m_mesh.connectivity());
       parallel_for(
-        m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+        m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
           const auto& cell_nodes = cell_to_node_matrix[j];
           xj[j]                  = 0.5 * (xr[cell_nodes[0]] + xr[cell_nodes[1]]);
         });
@@ -54,7 +54,7 @@ class MeshData
       const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
       CellValue<Rd> xj(m_mesh.connectivity());
       parallel_for(
-        m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+        m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
           Rd X                   = zero;
           const auto& cell_nodes = cell_to_node_matrix[j];
           for (size_t R = 0; R < cell_nodes.size(); ++R) {
@@ -75,7 +75,7 @@ class MeshData
 
     CellValue<double> Vj(m_mesh.connectivity());
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         double sum_cjr_xr      = 0;
         const auto& cell_nodes = cell_to_node_matrix[j];
 
@@ -100,7 +100,7 @@ class MeshData
       {
         NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
         parallel_for(
-          m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+          m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
             const auto& cell_nodes = cell_to_node_matrix[j];
             for (size_t R = 0; R < cell_nodes.size(); ++R) {
               int Rp1         = (R + 1) % cell_nodes.size();
@@ -115,14 +115,14 @@ class MeshData
       {
         NodeValuePerCell<double> ljr(m_mesh.connectivity());
         parallel_for(
-          m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
+          m_Cjr.numberOfValues(), PUGS_LAMBDA(size_t jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
         m_ljr = ljr;
       }
 
       {
         NodeValuePerCell<Rd> njr(m_mesh.connectivity());
         parallel_for(
-          m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
+          m_Cjr.numberOfValues(), PUGS_LAMBDA(size_t jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
         m_njr = njr;
       }
     } else if (Dimension == 3) {
@@ -132,7 +132,7 @@ class MeshData
       const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix();
 
       parallel_for(
-        m_mesh.numberOfFaces(), PUGS_LAMBDA(const FaceId& l) {
+        m_mesh.numberOfFaces(), PUGS_LAMBDA(FaceId l) {
           const auto& face_nodes = face_to_node_matrix[l];
           const size_t nb_nodes  = face_nodes.size();
           std::vector<Rd> dxr(nb_nodes);
@@ -161,10 +161,10 @@ class MeshData
       {
         NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
         parallel_for(
-          Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { Cjr[jr] = zero; });
+          Cjr.numberOfValues(), PUGS_LAMBDA(size_t jr) { Cjr[jr] = zero; });
 
         parallel_for(
-          m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+          m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
             const auto& cell_nodes = cell_to_node_matrix[j];
 
             const auto& cell_faces       = cell_to_face_matrix[j];
@@ -174,7 +174,7 @@ class MeshData
               const FaceId& l        = cell_faces[L];
               const auto& face_nodes = face_to_node_matrix[l];
 
-              auto local_node_number_in_cell = [&](const NodeId& node_number) {
+              auto local_node_number_in_cell = [&](NodeId node_number) {
                 for (size_t i_node = 0; i_node < cell_nodes.size(); ++i_node) {
                   if (node_number == cell_nodes[i_node]) {
                     return i_node;
@@ -203,14 +203,14 @@ class MeshData
       {
         NodeValuePerCell<double> ljr(m_mesh.connectivity());
         parallel_for(
-          m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
+          m_Cjr.numberOfValues(), PUGS_LAMBDA(size_t jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
         m_ljr = ljr;
       }
 
       {
         NodeValuePerCell<Rd> njr(m_mesh.connectivity());
         parallel_for(
-          m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
+          m_Cjr.numberOfValues(), PUGS_LAMBDA(size_t jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
         m_njr = njr;
       }
     }
@@ -275,7 +275,7 @@ class MeshData
       {
         NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
         parallel_for(
-          m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+          m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
             Cjr(j, 0) = -1;
             Cjr(j, 1) = 1;
           });
@@ -286,13 +286,16 @@ class MeshData
       {
         NodeValuePerCell<double> ljr(m_mesh.connectivity());
         parallel_for(
-          ljr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = 1; });
+          ljr.numberOfValues(), PUGS_LAMBDA(size_t jr) { ljr[jr] = 1; });
         m_ljr = ljr;
       }
     }
     this->updateAllData();
   }
 
+  MeshData(const MeshData&) = delete;
+  MeshData(MeshData&&)      = delete;
+
   ~MeshData()
   {
     ;
diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp
index 8a3d4c913b96c46ca7d7b93573b41eedc0312d24..e02c9b7520db65081977e4bb1774a348c9cd6e25 100644
--- a/src/mesh/MeshNodeBoundary.hpp
+++ b/src/mesh/MeshNodeBoundary.hpp
@@ -19,7 +19,7 @@
 #include <iostream>
 
 template <size_t Dimension>
-class MeshNodeBoundary
+class MeshNodeBoundary   // clazy:exclude=copyable-polymorphic
 {
  protected:
   Array<const NodeId> m_node_list;
@@ -42,7 +42,7 @@ class MeshNodeBoundary
 
     const Array<const FaceId>& face_list = ref_face_list.list();
     parallel_for(
-      face_list.size(), PUGS_LAMBDA(const int& l) {
+      face_list.size(), PUGS_LAMBDA(int l) {
         const auto& face_cells = face_to_cell_matrix[face_list[l]];
         if (face_cells.size() > 1) {
           throw NormalError("internal faces cannot be used to define mesh boundaries");
@@ -68,7 +68,7 @@ class MeshNodeBoundary
 
     Array<NodeId> node_list(node_ids.size());
     parallel_for(
-      node_ids.size(), PUGS_LAMBDA(const int& r) { node_list[r] = node_ids[r]; });
+      node_ids.size(), PUGS_LAMBDA(int r) { node_list[r] = node_ids[r]; });
     m_node_list = node_list;
   }
 
@@ -78,14 +78,16 @@ class MeshNodeBoundary
     static_assert(Dimension == MeshType::Dimension);
   }
 
-  MeshNodeBoundary()                        = default;
+  MeshNodeBoundary()          = default;
+  virtual ~MeshNodeBoundary() = default;
+
+ protected:
   MeshNodeBoundary(const MeshNodeBoundary&) = default;
   MeshNodeBoundary(MeshNodeBoundary&&)      = default;
-  virtual ~MeshNodeBoundary()               = default;
 };
 
 template <size_t Dimension>
-class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>
+class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>   // clazy:exclude=copyable-polymorphic
 {
  public:
   using Rd = TinyVector<Dimension, double>;
@@ -97,9 +99,9 @@ class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>
   PUGS_INLINE Rd _getNormal(const MeshType& mesh);
 
   template <typename MeshType>
-  PUGS_INLINE void _checkBoundaryIsFlat(const TinyVector<2, double>& normal,
-                                        const TinyVector<2, double>& xmin,
-                                        const TinyVector<2, double>& xmax,
+  PUGS_INLINE void _checkBoundaryIsFlat(TinyVector<2, double> normal,
+                                        TinyVector<2, double> xmin,
+                                        TinyVector<2, double> xmax,
                                         const MeshType& mesh) const;
 
   template <typename MeshType>
@@ -138,9 +140,9 @@ class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>
 template <>
 template <typename MeshType>
 void
-MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(const TinyVector<2, double>& normal,
-                                              const TinyVector<2, double>& xmin,
-                                              const TinyVector<2, double>& xmax,
+MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(TinyVector<2, double> normal,
+                                              TinyVector<2, double> xmin,
+                                              TinyVector<2, double> xmax,
                                               const MeshType& mesh) const
 {
   static_assert(MeshType::Dimension == 2);
@@ -152,7 +154,7 @@ MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(const TinyVector<2, double>& norma
   const NodeValue<const R2>& xr = mesh.xr();
 
   parallel_for(
-    m_node_list.size(), PUGS_LAMBDA(const size_t& r) {
+    m_node_list.size(), PUGS_LAMBDA(size_t r) {
       const R2& x = xr[m_node_list[r]];
       if ((x - origin, normal) > 1E-13 * length) {
         throw NormalError("this FlatBoundary is not flat!");
diff --git a/src/mesh/RefId.hpp b/src/mesh/RefId.hpp
index 35b9c4ef2966d151def68f29736b23a496cd8151..307324ee8bb0515fe79f046cfbf32c1eea89ec44 100644
--- a/src/mesh/RefId.hpp
+++ b/src/mesh/RefId.hpp
@@ -57,13 +57,12 @@ class RefId
   RefId(const RefId&)       = default;
   RefId(RefId&&)            = default;
 
-  explicit RefId(const TagNumberType& tag_number, const TagNameType& tag_name)
-    : m_tag_number(tag_number), m_tag_name(tag_name)
+  explicit RefId(TagNumberType tag_number, const TagNameType& tag_name) : m_tag_number(tag_number), m_tag_name(tag_name)
   {
     ;
   }
 
-  explicit RefId(const TagNumberType& tag_number) : m_tag_number(tag_number), m_tag_name(std::to_string(tag_number))
+  explicit RefId(TagNumberType tag_number) : m_tag_number(tag_number), m_tag_name(std::to_string(tag_number))
   {
     ;
   }
diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index d09af2536a526318eb88541572e48e1ab5ab791a..b43a779c7d6accfd510a22432ed15374fd194b39 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -61,14 +61,14 @@ class SubItemValuePerItem
 
    public:
     PUGS_INLINE
-    const DataType& operator[](const size_t& i) const noexcept(NO_ASSERT)
+    const DataType& operator[](size_t i) const noexcept(NO_ASSERT)
     {
       Assert(i < m_size);
       return m_sub_values[i];
     }
 
     PUGS_FORCEINLINE
-    DataType& operator[](const size_t& i) noexcept(NO_ASSERT)
+    DataType& operator[](size_t i) noexcept(NO_ASSERT)
     {
       Assert(i < m_size);
       return m_sub_values[i];
@@ -87,7 +87,7 @@ class SubItemValuePerItem
     SubView(SubView&&) noexcept = default;
 
     PUGS_INLINE
-    SubView(const Array<DataType>& values, const size_t& begin, const size_t& end) noexcept(NO_ASSERT)
+    SubView(const Array<DataType>& values, size_t begin, size_t end) noexcept(NO_ASSERT)
       : m_sub_values(&(values[begin])), m_size(end - begin)
     {
       Assert(begin <= end);
@@ -106,7 +106,7 @@ class SubItemValuePerItem
   // changes in data
   PUGS_FORCEINLINE
   DataType&
-  operator()(const ItemId& j, const size_t& r) const noexcept(NO_ASSERT)
+  operator()(ItemId j, size_t r) const noexcept(NO_ASSERT)
   {
     Assert(this->isBuilt());
     return m_values[m_host_row_map(size_t{j}) + r];
@@ -114,7 +114,7 @@ class SubItemValuePerItem
 
   template <typename IndexType>
   PUGS_FORCEINLINE DataType&
-  operator()(const IndexType& j, const size_t& r) const noexcept(NO_ASSERT)
+  operator()(IndexType j, size_t r) const noexcept(NO_ASSERT)
   {
     static_assert(std::is_same_v<IndexType, ItemId>, "SubItemValuePerItem indexed by ItemId");
     Assert(this->isBuilt());
@@ -132,7 +132,7 @@ class SubItemValuePerItem
   // Following Kokkos logic, these classes are view and const view does allow
   // changes in data
   PUGS_FORCEINLINE
-  DataType& operator[](const size_t& i) const noexcept(NO_ASSERT)
+  DataType& operator[](size_t i) const noexcept(NO_ASSERT)
   {
     Assert(this->isBuilt());
     return m_values[i];
@@ -158,7 +158,7 @@ class SubItemValuePerItem
 
   PUGS_INLINE
   size_t
-  numberOfSubValues(const size_t& i_cell) const noexcept(NO_ASSERT)
+  numberOfSubValues(size_t i_cell) const noexcept(NO_ASSERT)
   {
     Assert(this->isBuilt());
     return m_host_row_map(i_cell + 1) - m_host_row_map(i_cell);
@@ -166,7 +166,7 @@ class SubItemValuePerItem
 
   PUGS_INLINE
   SubView
-  itemValues(const size_t& i_cell) noexcept(NO_ASSERT)
+  itemValues(size_t i_cell) noexcept(NO_ASSERT)
   {
     Assert(this->isBuilt());
     const auto& cell_begin = m_host_row_map(i_cell);
@@ -178,7 +178,7 @@ class SubItemValuePerItem
   // changes in data
   PUGS_INLINE
   SubView
-  itemValues(const size_t& i_cell) const noexcept(NO_ASSERT)
+  itemValues(size_t i_cell) const noexcept(NO_ASSERT)
   {
     Assert(this->isBuilt());
     const auto& cell_begin = m_host_row_map(i_cell);
diff --git a/src/mesh/SynchronizerManager.hpp b/src/mesh/SynchronizerManager.hpp
index e2f89cbdad0a41cc260abcee39e602f11168ba31..e0e4519c1dd339cd7c67a5dbbeac4f49bf120a7c 100644
--- a/src/mesh/SynchronizerManager.hpp
+++ b/src/mesh/SynchronizerManager.hpp
@@ -16,6 +16,10 @@ class SynchronizerManager
   std::map<const IConnectivity*, std::shared_ptr<Synchronizer>> m_connectivity_synchronizer_map;
 
   static SynchronizerManager* m_instance;
+
+  SynchronizerManager(const SynchronizerManager&) = delete;
+  SynchronizerManager(SynchronizerManager&)       = delete;
+
   SynchronizerManager() = default;
   ~SynchronizerManager();
 
diff --git a/src/output/VTKWriter.hpp b/src/output/VTKWriter.hpp
index 8118e74346e1806c8caa50639c2fa63f77428545..7e818bec46b799ff0acf113230db894890141d78 100644
--- a/src/output/VTKWriter.hpp
+++ b/src/output/VTKWriter.hpp
@@ -32,7 +32,7 @@ class VTKWriter
     return sout.str();
   }
   std::string
-  _getFilenameVTU(const int& rank_number) const
+  _getFilenameVTU(int rank_number) const
   {
     std::ostringstream sout;
     sout << m_base_filename;
@@ -201,8 +201,8 @@ class VTKWriter
   void
   write(const MeshType& mesh,
         const OutputNamedItemValueSet& output_named_item_value_set,
-        const double& time,
-        const bool& forced_output = false)
+        double time,
+        bool forced_output = false)
   {
     if (time == m_last_time)
       return;   // output already performed
@@ -317,7 +317,7 @@ class VTKWriter
         Array<int8_t> types(mesh.numberOfCells());
         const auto& cell_type = mesh.connectivity().cellType();
         parallel_for(
-          mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+          mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
             switch (cell_type[j]) {
             case CellType::Line: {
               types[j] = 3;
diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp
index 1310ddc4c86389d62d17435820528f8ef22a540f..fd10ea3203b02cf624cc0ff0b5a556517ba84512 100644
--- a/src/scheme/AcousticSolver.hpp
+++ b/src/scheme/AcousticSolver.hpp
@@ -47,7 +47,7 @@ class AcousticSolver
   computeRhoCj(const CellValue<const double>& rhoj, const CellValue<const double>& cj)
   {
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_rhocj[j] = rhoj[j] * cj[j]; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_rhocj[j] = rhoj[j] * cj[j]; });
     return m_rhocj;
   }
 
@@ -59,7 +59,7 @@ class AcousticSolver
              const NodeValuePerCell<const Rd>& njr)
   {
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         const size_t& nb_nodes = m_Ajr.numberOfSubValues(j);
         const double& rho_c    = rhocj[j];
         for (size_t r = 0; r < nb_nodes; ++r) {
@@ -76,7 +76,7 @@ class AcousticSolver
     const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells();
 
     parallel_for(
-      m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
+      m_mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
         Rdd sum                                    = zero;
         const auto& node_to_cell                   = node_to_cell_matrix[r];
         const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemValues(r);
@@ -103,7 +103,7 @@ class AcousticSolver
     const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells();
 
     parallel_for(
-      m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
+      m_mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
         Rd& br                                     = m_br[r];
         br                                         = zero;
         const auto& node_to_cell                   = node_to_cell_matrix[r];
@@ -143,7 +143,7 @@ class AcousticSolver
 
         const Array<const NodeId>& node_list = symmetry_bc.nodeList();
         parallel_for(
-          symmetry_bc.numberOfNodes(), PUGS_LAMBDA(const int& r_number) {
+          symmetry_bc.numberOfNodes(), PUGS_LAMBDA(int r_number) {
             const NodeId r = node_list[r_number];
 
             m_Ar[r] = P * m_Ar[r] * P + nxn;
@@ -161,7 +161,7 @@ class AcousticSolver
     inverse(Ar, m_inv_Ar);
     const NodeValue<const Rdd> invAr = m_inv_Ar;
     parallel_for(
-      m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { m_ur[r] = invAr[r] * br[r]; });
+      m_mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) { m_ur[r] = invAr[r] * br[r]; });
 
     return m_ur;
   }
@@ -176,7 +176,7 @@ class AcousticSolver
     const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         const auto& cell_nodes = cell_to_node_matrix[j];
 
         for (size_t r = 0; r < cell_nodes.size(); ++r) {
@@ -189,7 +189,7 @@ class AcousticSolver
   inverse(const NodeValue<const Rdd>& A, NodeValue<Rdd>& inv_A) const
   {
     parallel_for(
-      m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { inv_A[r] = ::inverse(A[r]); });
+      m_mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) { inv_A[r] = ::inverse(A[r]); });
   }
 
   PUGS_INLINE
@@ -254,7 +254,7 @@ class AcousticSolver
     const auto& cell_to_node_matrix           = m_mesh.connectivity().cellToNodeMatrix();
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         const auto& cell_nodes = cell_to_node_matrix[j];
 
         double S = 0;
@@ -268,7 +268,7 @@ class AcousticSolver
   }
 
   void
-  computeNextStep(const double&, const double& dt, UnknownsType& unknowns)
+  computeNextStep(double, double dt, UnknownsType& unknowns)
   {
     CellValue<double>& rhoj = unknowns.rhoj();
     CellValue<Rd>& uj       = unknowns.uj();
@@ -291,7 +291,7 @@ class AcousticSolver
 
     const CellValue<const double> inv_mj = unknowns.invMj();
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         const auto& cell_nodes = cell_to_node_matrix[j];
 
         Rd momentum_fluxes   = zero;
@@ -306,16 +306,16 @@ class AcousticSolver
       });
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { ej[j] = Ej[j] - 0.5 * (uj[j], uj[j]); });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { ej[j] = Ej[j] - 0.5 * (uj[j], uj[j]); });
 
     NodeValue<Rd> mutable_xr = m_mesh.mutableXr();
     parallel_for(
-      m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { mutable_xr[r] += dt * ur[r]; });
+      m_mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) { mutable_xr[r] += dt * ur[r]; });
     m_mesh_data.updateAllData();
 
     const CellValue<const double> mj = unknowns.mj();
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { rhoj[j] = mj[j] / Vj[j]; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { rhoj[j] = mj[j] / Vj[j]; });
   }
 };
 
diff --git a/src/scheme/BlockPerfectGas.hpp b/src/scheme/BlockPerfectGas.hpp
index 1a51da28ed344a12c601081ff9bf61721854a631..38aef3262a39101fdc7607143a0bdb0e36d4cfe5 100644
--- a/src/scheme/BlockPerfectGas.hpp
+++ b/src/scheme/BlockPerfectGas.hpp
@@ -32,7 +32,7 @@ struct BlockPerfectGas
     const CellValue<const double>& gamma = m_gammaj;
 
     parallel_for(
-      nj, PUGS_LAMBDA(const CellId& j) {
+      nj, PUGS_LAMBDA(CellId j) {
         const double gamma_minus_one = gamma[j] - 1;
         m_pj[j]                      = gamma_minus_one * rho[j] * e[j];
         m_cj[j]                      = std::sqrt(gamma[j] * gamma_minus_one * e[j]);
@@ -48,11 +48,11 @@ struct BlockPerfectGas
     const CellValue<const double>& gamma = m_gammaj;
 
     parallel_for(
-      nj, PUGS_LAMBDA(const CellId& j) { m_ej[j] = p[j] / (rho[j] * (gamma[j] - 1)); });
+      nj, PUGS_LAMBDA(CellId j) { m_ej[j] = p[j] / (rho[j] * (gamma[j] - 1)); });
 
     const CellValue<const double>& e = m_ej;
     parallel_for(
-      nj, PUGS_LAMBDA(const CellId& j) { m_cj[j] = std::sqrt(gamma[j] * (gamma[j] - 1) * e[j]); });
+      nj, PUGS_LAMBDA(CellId j) { m_cj[j] = std::sqrt(gamma[j] * (gamma[j] - 1) * e[j]); });
   }
 };
 
diff --git a/src/scheme/BoundaryCondition.hpp b/src/scheme/BoundaryCondition.hpp
index 9e1c65cd3b45a71cc996d419acfc17cdc33f82c2..3d3332fc92cfa88792ecf556cb97781de007a104 100644
--- a/src/scheme/BoundaryCondition.hpp
+++ b/src/scheme/BoundaryCondition.hpp
@@ -9,7 +9,7 @@
 #include <memory>
 #include <vector>
 
-class BoundaryCondition
+class BoundaryCondition   // clazy:exclude=copyable-polymorphic
 {
  public:
   enum Type
@@ -23,7 +23,7 @@ class BoundaryCondition
   const Type m_type;
 
  protected:
-  BoundaryCondition(const Type& type) : m_type(type)
+  BoundaryCondition(Type type) : m_type(type)
   {
     ;
   }
@@ -38,7 +38,7 @@ class BoundaryCondition
   virtual ~BoundaryCondition() = default;
 };
 
-class PressureBoundaryCondition : public BoundaryCondition
+class PressureBoundaryCondition final : public BoundaryCondition   // clazy:exclude=copyable-polymorphic
 {
  private:
   const double m_value;
@@ -65,12 +65,12 @@ class PressureBoundaryCondition : public BoundaryCondition
     return m_face_list;
   }
 
-  PressureBoundaryCondition(const double& value, const std::vector<unsigned int>& faces)
+  PressureBoundaryCondition(double value, const std::vector<unsigned int>& faces)
     : BoundaryCondition(BoundaryCondition::pressure), m_value(value), m_number_of_faces(faces.size())
   {
     Array<unsigned int> face_list(faces.size());
     parallel_for(
-      m_number_of_faces, PUGS_LAMBDA(const int& f) { face_list[f] = faces[f]; });
+      m_number_of_faces, PUGS_LAMBDA(int f) { face_list[f] = faces[f]; });
     m_face_list = face_list;
   }
 
diff --git a/src/scheme/BoundaryConditionDescriptor.hpp b/src/scheme/BoundaryConditionDescriptor.hpp
index b73cd6fca1211c2adbb48d7a177e13c28831e0f1..8f4911ad940c56b335fabb1e002582f5d61ddd34 100644
--- a/src/scheme/BoundaryConditionDescriptor.hpp
+++ b/src/scheme/BoundaryConditionDescriptor.hpp
@@ -30,10 +30,13 @@ class BoundaryDescriptor
   {
     return bcd == ref_id;
   }
-  virtual Type type() const                     = 0;
-  BoundaryDescriptor(const BoundaryDescriptor&) = default;
+  virtual Type type() const = 0;
+
+  BoundaryDescriptor(const BoundaryDescriptor&) = delete;
+  BoundaryDescriptor(BoundaryDescriptor&&)      = delete;
   BoundaryDescriptor()                          = default;
-  virtual ~BoundaryDescriptor()                 = default;
+
+  virtual ~BoundaryDescriptor() = default;
 };
 
 class NamedBoundaryDescriptor : public BoundaryDescriptor
@@ -61,7 +64,8 @@ class NamedBoundaryDescriptor : public BoundaryDescriptor
     return Type::named;
   }
 
-  NamedBoundaryDescriptor(const NamedBoundaryDescriptor&) = default;
+  NamedBoundaryDescriptor(const NamedBoundaryDescriptor&) = delete;
+  NamedBoundaryDescriptor(NamedBoundaryDescriptor&&)      = delete;
   NamedBoundaryDescriptor(const std::string& name) : m_name(name)
   {
     ;
@@ -94,8 +98,9 @@ class NumberedBoundaryDescriptor : public BoundaryDescriptor
     return Type::numbered;
   }
 
-  NumberedBoundaryDescriptor(const NumberedBoundaryDescriptor&) = default;
-  NumberedBoundaryDescriptor(const unsigned int& number) : m_number(number)
+  NumberedBoundaryDescriptor(const NumberedBoundaryDescriptor&) = delete;
+  NumberedBoundaryDescriptor(NumberedBoundaryDescriptor&&)      = delete;
+  NumberedBoundaryDescriptor(unsigned int number) : m_number(number)
   {
     ;
   }
@@ -136,6 +141,9 @@ class BoundaryConditionDescriptor
     ;
   }
 
+  BoundaryConditionDescriptor(const BoundaryConditionDescriptor&) = delete;
+  BoundaryConditionDescriptor(BoundaryConditionDescriptor&&)      = delete;
+
   virtual ~BoundaryConditionDescriptor() = default;
 };
 
@@ -162,8 +170,10 @@ class SymmetryBoundaryConditionDescriptor : public BoundaryConditionDescriptor
     ;
   }
 
-  SymmetryBoundaryConditionDescriptor(const SymmetryBoundaryConditionDescriptor&) = default;
-  ~SymmetryBoundaryConditionDescriptor()                                          = default;
+  SymmetryBoundaryConditionDescriptor(const SymmetryBoundaryConditionDescriptor&) = delete;
+  SymmetryBoundaryConditionDescriptor(SymmetryBoundaryConditionDescriptor&&)      = delete;
+
+  ~SymmetryBoundaryConditionDescriptor() = default;
 };
 
 #endif   // BOUNDARY_CONDITION_DESCRIPTOR_HPP
diff --git a/src/scheme/FiniteVolumesEulerUnknowns.hpp b/src/scheme/FiniteVolumesEulerUnknowns.hpp
index bc55835ede9b323f15558561845332b1384162d3..a3fd012de3d0ea44fd8b0cfe724238bb115fa05c 100644
--- a/src/scheme/FiniteVolumesEulerUnknowns.hpp
+++ b/src/scheme/FiniteVolumesEulerUnknowns.hpp
@@ -145,7 +145,7 @@ class FiniteVolumesEulerUnknowns
     const CellValue<const Rd>& xj = m_mesh_data.xj();
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         if (xj[j][0] < 0.5) {
           m_rhoj[j] = 1;
         } else {
@@ -154,7 +154,7 @@ class FiniteVolumesEulerUnknowns
       });
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
         if (xj[j][0] < 0.5) {
           m_pj[j] = 1;
         } else {
@@ -163,23 +163,23 @@ class FiniteVolumesEulerUnknowns
       });
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_uj[j] = zero; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_uj[j] = zero; });
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_gammaj[j] = 1.4; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_gammaj[j] = 1.4; });
 
     BlockPerfectGas block_eos(m_rhoj, m_ej, m_pj, m_gammaj, m_cj);
     block_eos.updateEandCFromRhoP();
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_Ej[j] = m_ej[j] + 0.5 * (m_uj[j], m_uj[j]); });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_Ej[j] = m_ej[j] + 0.5 * (m_uj[j], m_uj[j]); });
 
     const CellValue<const double>& Vj = m_mesh_data.Vj();
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_mj[j] = m_rhoj[j] * Vj[j]; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_mj[j] = m_rhoj[j] * Vj[j]; });
 
     parallel_for(
-      m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_inv_mj[j] = 1. / m_mj[j]; });
+      m_mesh.numberOfCells(), PUGS_LAMBDA(CellId j) { m_inv_mj[j] = 1. / m_mj[j]; });
   }
 
   FiniteVolumesEulerUnknowns(const MeshDataType& mesh_data)
diff --git a/src/utils/Array.hpp b/src/utils/Array.hpp
index 2d6668c68db33aa0816f9f83ef0c95d95ede0e64..42ae7f61c375a9cb544020063f827c43dcf5e143 100644
--- a/src/utils/Array.hpp
+++ b/src/utils/Array.hpp
@@ -43,7 +43,7 @@ class Array
   friend PUGS_INLINE Array<DataType2> encapsulate(const Kokkos::View<DataType2*, RT...>& values);
 
   PUGS_INLINE
-  DataType& operator[](const index_type& i) const noexcept(NO_ASSERT)
+  DataType& operator[](index_type i) const noexcept(NO_ASSERT)
   {
     Assert(i < m_values.extent(0));
     return m_values[i];
@@ -57,7 +57,7 @@ class Array
 
     // could consider to use std::fill
     parallel_for(
-      this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] = data; });
+      this->size(), PUGS_LAMBDA(index_type i) { m_values[i] = data; });
   }
 
   template <typename DataType2>
@@ -81,7 +81,7 @@ class Array
   Array& operator=(Array&&) = default;
 
   PUGS_INLINE
-  Array(const size_t& size) : m_values("anonymous", size)
+  Array(size_t size) : m_values("anonymous", size)
   {
     static_assert(not std::is_const<DataType>(), "Cannot allocate Array of const data: only view is "
                                                  "supported");
diff --git a/src/utils/ArrayUtils.hpp b/src/utils/ArrayUtils.hpp
index 6b5b09685ce6266cce13fdce10930750111909da..d85fb162756deb20d19971470ea1f40421dfdfa1 100644
--- a/src/utils/ArrayUtils.hpp
+++ b/src/utils/ArrayUtils.hpp
@@ -203,7 +203,7 @@ value_copy(const SourceArray<SourceT...>& source_array, ImageArray<ImageT...>& i
   Assert(source_array.size() == image_array.size());
 
   parallel_for(
-    source_array.size(), PUGS_LAMBDA(const size_t& i) { image_array[i] = source_array[i]; });
+    source_array.size(), PUGS_LAMBDA(size_t i) { image_array[i] = source_array[i]; });
 }
 
 #endif   // ARRAY_UTILS_HPP
diff --git a/src/utils/CSRGraph.hpp b/src/utils/CSRGraph.hpp
index f2e8ea2865e5ea69a1deda594caee2f57e207dfe..a3ae85dcced1897fc54901903c919f0009761d74 100644
--- a/src/utils/CSRGraph.hpp
+++ b/src/utils/CSRGraph.hpp
@@ -32,7 +32,7 @@ class CSRGraph
   CSRGraph& operator=(CSRGraph&&) = default;
   CSRGraph& operator=(const CSRGraph&) = default;
 
-  CSRGraph(Array<int> entries, Array<int> neighbors) : m_entries(entries), m_neighbors(neighbors)
+  CSRGraph(const Array<int>& entries, const Array<int>& neighbors) : m_entries(entries), m_neighbors(neighbors)
   {
     Assert(m_entries.size() > 0);
   }
diff --git a/src/utils/CastArray.hpp b/src/utils/CastArray.hpp
index 26397a1605f2384efab5f4ff7fcf9bd1c78241e8..120bcc25c1f5dd9da75a387016bad8d2b5175688 100644
--- a/src/utils/CastArray.hpp
+++ b/src/utils/CastArray.hpp
@@ -27,7 +27,7 @@ class CastArray
   }
 
   PUGS_INLINE
-  CastDataType& operator[](const size_t& i) const
+  CastDataType& operator[](size_t i) const
   {
     Assert(i < m_size);
     return m_values[i];
diff --git a/src/utils/ConsoleManager.cpp b/src/utils/ConsoleManager.cpp
index aa6d23b042a9f7aa7365d6d38668183a154de800..666caa1b17c5bb397e592132febeabab4846732f 100644
--- a/src/utils/ConsoleManager.cpp
+++ b/src/utils/ConsoleManager.cpp
@@ -9,7 +9,7 @@ ConsoleManager::isTerminal(std::ostream& os)
 }
 
 void
-ConsoleManager::init(const bool& colorize)
+ConsoleManager::init(bool colorize)
 {
   std::cout << "Console management: color ";
   if (colorize) {
diff --git a/src/utils/ConsoleManager.hpp b/src/utils/ConsoleManager.hpp
index 8befab9f6d78aa72c25f4c768ebda530e4545096..b9ee7cbfbf123af63f131d07df8655c6f6ba4f85 100644
--- a/src/utils/ConsoleManager.hpp
+++ b/src/utils/ConsoleManager.hpp
@@ -6,7 +6,7 @@
 struct ConsoleManager
 {
   static bool isTerminal(std::ostream& os);
-  static void init(const bool& colorize);
+  static void init(bool colorize);
 };
 
 #endif   // CONSOLE_MANAGER_HPP
diff --git a/src/utils/Exceptions.hpp b/src/utils/Exceptions.hpp
index 1c0a56b4b7c4572faa13ae1fb9b82644d262418a..2b7906dfee7de16e848633597a7645c146084103 100644
--- a/src/utils/Exceptions.hpp
+++ b/src/utils/Exceptions.hpp
@@ -6,32 +6,51 @@
 struct IExitError : public std::runtime_error
 {
   IExitError(std::string_view error_msg) : std::runtime_error(std::string{error_msg}){};
+
+  IExitError(const IExitError&) = delete;
+  IExitError(IExitError&&)      = delete;
+
   virtual ~IExitError() = default;
 };
 
 struct RawError : public IExitError
 {
+  RawError(const RawError&) = delete;
+  RawError(RawError&&)      = delete;
+
   RawError(std::string_view error_msg);
 };
 
 struct NormalError : public IExitError
 {
+  NormalError(const NormalError&) = delete;
+  NormalError(NormalError&&)      = delete;
+
   NormalError(std::string_view error_msg);
 };
 
 struct IBacktraceError : public std::runtime_error
 {
+  IBacktraceError(const IBacktraceError&) = delete;
+  IBacktraceError(IBacktraceError&&)      = delete;
+
   IBacktraceError(const std::string& error_msg) : std::runtime_error(std::string{error_msg}){};
   virtual ~IBacktraceError() = default;
 };
 
 struct UnexpectedError : IBacktraceError
 {
+  UnexpectedError(const UnexpectedError&) = delete;
+  UnexpectedError(UnexpectedError&&)      = delete;
+
   UnexpectedError(std::string_view error_msg);
 };
 
 struct NotImplementedError : IBacktraceError
 {
+  NotImplementedError(const NotImplementedError&) = delete;
+  NotImplementedError(NotImplementedError&&)      = delete;
+
   NotImplementedError(std::string_view error_msg);
 };
 
diff --git a/src/utils/FPEManager.cpp b/src/utils/FPEManager.cpp
index 2bf268392c5a37dbf4bf058cf3f137ff6c7e13d5..7430b5bbcc8c17d31b3a9508a170bfb3ed525632 100644
--- a/src/utils/FPEManager.cpp
+++ b/src/utils/FPEManager.cpp
@@ -92,7 +92,7 @@ FPEManager::disable()
 #endif   // PUGS_HAS_FENV_H
 
 void
-FPEManager::init(const bool& enable)
+FPEManager::init(bool enable)
 {
   if (enable) {
     FPEManager::enable();
diff --git a/src/utils/FPEManager.hpp b/src/utils/FPEManager.hpp
index f90a477ed6def18fe07d48f1d95b7d028791d86c..57ffe2bccc5ea01bfcd1de1f093180aa43941de9 100644
--- a/src/utils/FPEManager.hpp
+++ b/src/utils/FPEManager.hpp
@@ -5,7 +5,7 @@ struct FPEManager
 {
   static void enable();
   static void disable();
-  static void init(const bool& enable);
+  static void init(bool enable);
 };
 
 #endif   // FPEMANAGER_HPP
diff --git a/src/utils/Messenger.hpp b/src/utils/Messenger.hpp
index b1acd5e0f11c5c6e6640a1e049a51087231be7d1..1f8903eccf8465e5d06ebc2164ec8f3768672289 100644
--- a/src/utils/Messenger.hpp
+++ b/src/utils/Messenger.hpp
@@ -137,7 +137,7 @@ class Messenger
 
   template <typename DataType>
   void
-  _broadcast_value([[maybe_unused]] DataType& data, [[maybe_unused]] const size_t& root_rank) const
+  _broadcast_value([[maybe_unused]] DataType& data, [[maybe_unused]] size_t root_rank) const
   {
     static_assert(not std::is_const_v<DataType>);
     static_assert(std::is_arithmetic_v<DataType>);
@@ -151,7 +151,7 @@ class Messenger
 
   template <typename ArrayType>
   void
-  _broadcast_array([[maybe_unused]] ArrayType& array, [[maybe_unused]] const size_t& root_rank) const
+  _broadcast_array([[maybe_unused]] ArrayType& array, [[maybe_unused]] size_t root_rank) const
   {
     using DataType = typename ArrayType::data_type;
     static_assert(not std::is_const_v<DataType>);
@@ -436,7 +436,7 @@ class Messenger
 
   template <typename DataType>
   PUGS_INLINE void
-  broadcast(DataType& data, const size_t& root_rank) const
+  broadcast(DataType& data, size_t root_rank) const
   {
     static_assert(not std::is_const_v<DataType>, "cannot broadcast const data");
     if constexpr (std::is_arithmetic_v<DataType>) {
@@ -457,7 +457,7 @@ class Messenger
 
   template <typename DataType>
   PUGS_INLINE void
-  broadcast(Array<DataType>& array, const size_t& root_rank) const
+  broadcast(Array<DataType>& array, size_t root_rank) const
   {
     static_assert(not std::is_const_v<DataType>, "cannot broadcast array of const");
     if constexpr (std::is_arithmetic_v<DataType>) {
@@ -546,7 +546,7 @@ PUGS_INLINE
 void
 barrier()
 {
-  return messenger().barrier();
+  messenger().barrier();
 }
 
 template <typename DataType>
@@ -593,14 +593,14 @@ allToAll(const Array<DataType>& array)
 
 template <typename DataType>
 PUGS_INLINE void
-broadcast(DataType& data, const size_t& root_rank)
+broadcast(DataType& data, size_t root_rank)
 {
   messenger().broadcast(data, root_rank);
 }
 
 template <typename DataType>
 PUGS_INLINE void
-broadcast(Array<DataType>& array, const size_t& root_rank)
+broadcast(Array<DataType>& array, size_t root_rank)
 {
   messenger().broadcast(array, root_rank);
 }
diff --git a/src/utils/PugsAssert.hpp b/src/utils/PugsAssert.hpp
index 82d1db70bb0b5ca9e8cfa92070828f338a6a96de..15c47de7d1adae3482f3b06d4a0e6a8e55c6861d 100644
--- a/src/utils/PugsAssert.hpp
+++ b/src/utils/PugsAssert.hpp
@@ -35,7 +35,11 @@ class AssertError
   }
 
   AssertError(const AssertError&) = default;
-  AssertError(std::string file, int line, std::string function, std::string test, std::string message = "")
+  AssertError(const std::string& file,
+              int line,
+              const std::string& function,
+              const std::string& test,
+              const std::string& message = "")
     : m_file(file), m_line(line), m_function(function), m_test(test), m_message(message)
   {
     ;
@@ -45,7 +49,7 @@ class AssertError
 };
 
 PRAGMA_DIAGNOSTIC_IGNORED_WATTRIBUTES
-inline bool __attribute__((analyzer_noreturn)) _pugs_assert(const bool& assert)
+inline bool __attribute__((analyzer_noreturn)) _pugs_assert(bool assert)
 {
   return assert;
 }
diff --git a/src/utils/PugsUtils.hpp b/src/utils/PugsUtils.hpp
index 6a64867dbc3dc7c5fe21a9cf254efb704cb1655a..ef4eeb72c340b8a6ca654d001c32390973b63c55 100644
--- a/src/utils/PugsUtils.hpp
+++ b/src/utils/PugsUtils.hpp
@@ -9,14 +9,14 @@
 
 template <typename FunctionType>
 PUGS_FORCEINLINE void
-parallel_for(const size_t& size, const FunctionType& lambda, const std::string& label = "")
+parallel_for(size_t size, const FunctionType& lambda, const std::string& label = "")
 {
   Kokkos::parallel_for(size, lambda, label);
 }
 
 template <typename ArrayType, typename ReturnType>
 PUGS_FORCEINLINE void
-parallel_reduce(const size_t& size, const ArrayType& array, ReturnType& value, const std::string& label = "")
+parallel_reduce(size_t size, const ArrayType& array, ReturnType& value, const std::string& label = "")
 {
   Kokkos::parallel_reduce(label, size, array, value);
 }
diff --git a/src/utils/SignalManager.cpp b/src/utils/SignalManager.cpp
index 45a6dd49d68d94206312203d509fba673b15ebd2..ab08424fa2731bc62d84b461cea850878da9514b 100644
--- a/src/utils/SignalManager.cpp
+++ b/src/utils/SignalManager.cpp
@@ -22,13 +22,13 @@ SignalManager::pauseOnError()
 }
 
 void
-SignalManager::setPauseForDebug(const bool& pause_on_error)
+SignalManager::setPauseForDebug(bool pause_on_error)
 {
   s_pause_on_error = pause_on_error;
 }
 
 std::string
-SignalManager::signalName(const int& signal)
+SignalManager::signalName(int signal)
 {
   switch (signal) {
   case SIGILL:
@@ -48,7 +48,7 @@ SignalManager::signalName(const int& signal)
 }
 
 void
-SignalManager::pauseForDebug(const int& signal)
+SignalManager::pauseForDebug(int signal)
 {
   if (std::string(PUGS_BUILD_TYPE) != "Release") {
     if (s_pause_on_error) {
@@ -105,7 +105,7 @@ SignalManager::handler(int signal)
 }
 
 void
-SignalManager::init(const bool& enable)
+SignalManager::init(bool enable)
 {
   if (enable) {
     std::signal(SIGFPE, SignalManager::handler);
diff --git a/src/utils/SignalManager.hpp b/src/utils/SignalManager.hpp
index b64195e7ee0e0800a3dd764aa1bce60b370e5f9b..6f24613f4d074ac7377002bf83cb76f3e22dc8b1 100644
--- a/src/utils/SignalManager.hpp
+++ b/src/utils/SignalManager.hpp
@@ -7,14 +7,14 @@ struct SignalManager
 {
  private:
   static bool s_pause_on_error;
-  static std::string signalName(const int& signal);
-  static void pauseForDebug(const int& signal);
+  static std::string signalName(int signal);
+  static void pauseForDebug(int signal);
   static void handler(int signal);
 
  public:
   static bool pauseOnError();
-  static void setPauseForDebug(const bool& pause_on_error);
-  static void init(const bool& enable);
+  static void setPauseForDebug(bool pause_on_error);
+  static void init(bool enable);
 };
 
 #endif   // SIGNAL_MANAGER_HPP
diff --git a/tests/mpi_test_Messenger.cpp b/tests/mpi_test_Messenger.cpp
index b044547b8de081e7379dd4fb395d9c83557e51a0..beea7430bc83b17b11dc6ab2375f70d5a13e785a 100644
--- a/tests/mpi_test_Messenger.cpp
+++ b/tests/mpi_test_Messenger.cpp
@@ -19,16 +19,19 @@ namespace mpi_check
 struct integer
 {
   int m_int;
+
   operator int&()
   {
     return m_int;
   }
+
   operator const int&() const
   {
     return m_int;
   }
+
   integer&
-  operator=(const int& i)
+  operator=(int i)
   {
     m_int = i;
     return *this;
@@ -47,8 +50,9 @@ struct tri_int
   int m_int_0;
   int m_int_1;
   int m_int_2;
+
   bool
-  operator==(const tri_int& t) const
+  operator==(tri_int t) const
   {
     return ((m_int_0 == t.m_int_0) and (m_int_1 == t.m_int_1) and (m_int_2 == t.m_int_2));
   }