diff --git a/Applications/DataExplorer/DataView/MeshModel.h b/Applications/DataExplorer/DataView/MeshModel.h
index 19cfdce43aed0a2e8853b71a8fc7b0771f2004e1..684896487a683ac02560d25b7ed74501f9e5e4b1 100644
--- a/Applications/DataExplorer/DataView/MeshModel.h
+++ b/Applications/DataExplorer/DataView/MeshModel.h
@@ -59,7 +59,7 @@ public slots:
     /// Removes the mesh with the given name.
     bool removeMesh(const std::string &name);
     /// Updates the model/view for a mesh.
-    void updateMesh(MeshLib::Mesh*);
+    void updateMesh(MeshLib::Mesh* /*mesh*/);
     /// Updates the model based on the ProjectData-object
     void updateModel();
     /// Returns the VTK source item for the mesh with the given index.
diff --git a/Applications/DataExplorer/VtkVis/VtkConsoleOutputWindow.h b/Applications/DataExplorer/VtkVis/VtkConsoleOutputWindow.h
index b6db5d80a8352197084272da1e75d560036493b4..c80f5c580e5ce10a4c79a813bbf152c703e065e8 100644
--- a/Applications/DataExplorer/VtkVis/VtkConsoleOutputWindow.h
+++ b/Applications/DataExplorer/VtkVis/VtkConsoleOutputWindow.h
@@ -24,7 +24,7 @@ public:
     void PrintSelf(ostream& os, vtkIndent indent) override;
 
     static VtkConsoleOutputWindow * New();
-    void DisplayText(const char*) override;
+    void DisplayText(const char* /*unused*/) override;
 
     VtkConsoleOutputWindow(const VtkConsoleOutputWindow&) = delete;
     void operator=(const VtkConsoleOutputWindow&) = delete;
diff --git a/Applications/FileIO/Gmsh/GMSHAdaptiveMeshDensity.h b/Applications/FileIO/Gmsh/GMSHAdaptiveMeshDensity.h
index f1036515ddf62819d2120a813606eaaa2385e265..8c7ac58e0a4fb8bae49b1759cf70e824e15a7218 100644
--- a/Applications/FileIO/Gmsh/GMSHAdaptiveMeshDensity.h
+++ b/Applications/FileIO/Gmsh/GMSHAdaptiveMeshDensity.h
@@ -37,7 +37,8 @@ public:
     void initialize(std::vector<GeoLib::Point const*> const& pnts) override;
     double getMeshDensityAtPoint(GeoLib::Point const* const pnt) const override;
     void addPoints(std::vector<GeoLib::Point const*> const& pnts);
-    double getMeshDensityAtStation(GeoLib::Point const* const) const override;
+    double getMeshDensityAtStation(
+        GeoLib::Point const* const /*unused*/) const override;
     void getSteinerPoints (std::vector<GeoLib::Point*> & pnts,
                            std::size_t additional_levels = 0) const;
 #ifndef NDEBUG
diff --git a/Applications/FileIO/Gmsh/GMSHFixedMeshDensity.h b/Applications/FileIO/Gmsh/GMSHFixedMeshDensity.h
index 34b3f6193959086ef79c56811f4b9feda1232bf9..b838a680e0258dfdacfc4c9fecdf7d45cb0df45d 100644
--- a/Applications/FileIO/Gmsh/GMSHFixedMeshDensity.h
+++ b/Applications/FileIO/Gmsh/GMSHFixedMeshDensity.h
@@ -22,8 +22,10 @@ class GMSHFixedMeshDensity final : public GMSHMeshDensityStrategy
 public:
     explicit GMSHFixedMeshDensity(double mesh_density);
     void initialize(std::vector<GeoLib::Point const*> const& vec) override;
-    double getMeshDensityAtPoint(GeoLib::Point const* const) const override;
-    double getMeshDensityAtStation(GeoLib::Point const* const) const override;
+    double getMeshDensityAtPoint(
+        GeoLib::Point const* const /*unused*/) const override;
+    double getMeshDensityAtStation(
+        GeoLib::Point const* const /*unused*/) const override;
     ~GMSHFixedMeshDensity() override = default;
 
 private:
diff --git a/BaseLib/ConfigTree-impl.h b/BaseLib/ConfigTree-impl.h
index 9acdf51c07393bdcf350664932dd6092fcc08916..a4ffe1907640d15873f4801df43cea4d14f3d140 100644
--- a/BaseLib/ConfigTree-impl.h
+++ b/BaseLib/ConfigTree-impl.h
@@ -71,7 +71,7 @@ boost::optional<T> ConfigTree::getConfigParameterOptional(
 
 template <typename T>
 boost::optional<T> ConfigTree::getConfigParameterOptionalImpl(
-    std::string const& param, T*) const
+    std::string const& param, T* /*unused*/) const
 {
     if (auto p = getConfigSubtreeOptional(param))
     {
@@ -83,7 +83,7 @@ boost::optional<T> ConfigTree::getConfigParameterOptionalImpl(
 
 template <typename T>
 boost::optional<std::vector<T>> ConfigTree::getConfigParameterOptionalImpl(
-    std::string const& param, std::vector<T>*) const
+    std::string const& param, std::vector<T>* /*unused*/) const
 {
     if (auto p = getConfigSubtreeOptional(param))
     {
diff --git a/BaseLib/ConfigTree.h b/BaseLib/ConfigTree.h
index a7634b56ba9d136dce4309218c2c539ec6a05888..7f55a51f06f9eff9987d5b12f3481ef35c3b0ccc 100644
--- a/BaseLib/ConfigTree.h
+++ b/BaseLib/ConfigTree.h
@@ -268,7 +268,7 @@ public:
 
     //! After being moved from, \c other is in an undefined state and must not be
     //! used anymore!
-    ConfigTree& operator=(ConfigTree &&);
+    ConfigTree& operator=(ConfigTree&& other);
 
     //! Used to get the project file name.
     std::string const& getProjectFileName() const { return _filename; }
@@ -520,12 +520,14 @@ public:
 
 private:
     //! Default implementation of reading a value of type T.
-    template<typename T> boost::optional<T>
-    getConfigParameterOptionalImpl(std::string const& param, T*) const;
+    template <typename T>
+    boost::optional<T> getConfigParameterOptionalImpl(std::string const& param,
+                                                      T* /*unused*/) const;
 
     //! Implementation of reading a vector of values of type T.
-    template<typename T> boost::optional<std::vector<T>>
-    getConfigParameterOptionalImpl(std::string const& param, std::vector<T>*) const;
+    template <typename T>
+    boost::optional<std::vector<T>> getConfigParameterOptionalImpl(
+        std::string const& param, std::vector<T>* /*unused*/) const;
 
     struct CountType
     {
diff --git a/BaseLib/Functional.h b/BaseLib/Functional.h
index 09f0c0ff0f0bf81969c275040f670a57766953da..632414a92c3376a75e4a123afa3c755f766377fd 100644
--- a/BaseLib/Functional.h
+++ b/BaseLib/Functional.h
@@ -100,7 +100,7 @@ template <int... Indices, typename Object, typename MethodClass,
           typename ReturnType, typename... Args>
 std::function<ReturnType(Args...)> easyBind_inner(
     ReturnType (MethodClass::*method)(Args...), Object&& obj,
-    std::integer_sequence<int, Indices...>)
+    std::integer_sequence<int, Indices...> /*unused*/)
 {
     return easyBind_innermost<Indices...>(method, std::forward<Object>(obj));
 }
@@ -109,7 +109,7 @@ template <int... Indices, typename Object, typename MethodClass,
           typename ReturnType, typename... Args>
 std::function<ReturnType(Args...)> easyBind_inner(
     ReturnType (MethodClass::*method)(Args...) const, Object&& obj,
-    std::integer_sequence<int, Indices...>)
+    std::integer_sequence<int, Indices...> /*unused*/)
 {
     return easyBind_innermost<Indices...>(method, std::forward<Object>(obj));
 }
diff --git a/BaseLib/TCLAPCustomOutput.h b/BaseLib/TCLAPCustomOutput.h
index 3c3ef0034f4c2f3a7d56b4060bcc9c7c4e6782ee..0154040ef28511cdd71d8b0bdd9e70aab817ce63 100644
--- a/BaseLib/TCLAPCustomOutput.h
+++ b/BaseLib/TCLAPCustomOutput.h
@@ -35,7 +35,7 @@ public:
      * produce alternative behavior.
      * \param c - The CmdLine object the output is generated for.
      */
-    virtual void usage(TCLAP::CmdLineInterface& c);
+    virtual void usage(TCLAP::CmdLineInterface& _cmd);
 
     /**
      * Prints (to stderr) an error message, short usage
@@ -43,8 +43,7 @@ public:
      * \param c - The CmdLine object the output is generated for.
      * \param e - The ArgException that caused the failure.
      */
-    virtual void failure(TCLAP::CmdLineInterface& c,
-            TCLAP::ArgException& e );
+    virtual void failure(TCLAP::CmdLineInterface& _cmd, TCLAP::ArgException& e);
 
 protected:
 
@@ -53,7 +52,7 @@ protected:
      * \param c - The CmdLine object the output is generated for.
      * \param os - The stream to write the message to.
      */
-    void _shortUsage( TCLAP::CmdLineInterface& c, std::ostream& os ) const;
+    void _shortUsage(TCLAP::CmdLineInterface& _cmd, std::ostream& os) const;
 
     /**
      * Writes a longer usage message with long and short args,
@@ -61,8 +60,7 @@ protected:
      * \param c - The CmdLine object the output is generated for.
      * \param os - The stream to write the message to.
      */
-    void _longUsage( TCLAP::CmdLineInterface& c, std::ostream& os ) const;
-
+    void _longUsage(TCLAP::CmdLineInterface& _cmd, std::ostream& os) const;
 };
 
 inline void TCLAPCustomOutput::usage(TCLAP::CmdLineInterface& _cmd )
diff --git a/GeoLib/GEOObjects.h b/GeoLib/GEOObjects.h
index abf5218d9c737448f53ff217c299b151e9a2a4c2..5772f49776e9f24168567859c4644b7fe211a928 100644
--- a/GeoLib/GEOObjects.h
+++ b/GeoLib/GEOObjects.h
@@ -64,17 +64,20 @@ class GEOObjects final
 public:
     struct Callbacks
     {
-        virtual void addPointVec(std::string const&){}
-        virtual void removePointVec(std::string const&){}
-        virtual void addStationVec(std::string const&){}
-        virtual void removeStationVec(std::string const&){}
-        virtual void addPolylineVec(std::string const&){}
-        virtual void appendPolylineVec(std::string const&){}
-        virtual void removePolylineVec(std::string const&){}
-        virtual void addSurfaceVec(std::string const&){}
-        virtual void appendSurfaceVec(std::string const&){}
-        virtual void removeSurfaceVec(std::string const&){}
-        virtual void renameGeometry(std::string const&, std::string const&) {}
+        virtual void addPointVec(std::string const& /*unused*/) {}
+        virtual void removePointVec(std::string const& /*unused*/) {}
+        virtual void addStationVec(std::string const& /*unused*/) {}
+        virtual void removeStationVec(std::string const& /*unused*/) {}
+        virtual void addPolylineVec(std::string const& /*unused*/) {}
+        virtual void appendPolylineVec(std::string const& /*unused*/) {}
+        virtual void removePolylineVec(std::string const& /*unused*/) {}
+        virtual void addSurfaceVec(std::string const& /*unused*/) {}
+        virtual void appendSurfaceVec(std::string const& /*unused*/) {}
+        virtual void removeSurfaceVec(std::string const& /*unused*/) {}
+        virtual void renameGeometry(std::string const& /*unused*/,
+                                    std::string const& /*unused*/)
+        {
+        }
         virtual ~Callbacks() = default;
     };
 
@@ -308,34 +311,22 @@ public:
     std::unique_ptr<Callbacks> _callbacks{new Callbacks};
 
     std::function<void(std::string const&)> addPolylineVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
     std::function<void(std::string const&)> appendPolylineVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
     std::function<void(std::string const&)> removePolylineVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
     std::function<void(std::string const&)> addSurfaceVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
     std::function<void(std::string const&)> appendSurfaceVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
     std::function<void(std::string const&)> removeSurfaceVecCallback =
-        [](std::string const&)
-    {
-    };
+        [](std::string const& /*unused*/) {};
 
 private:
     /**
diff --git a/GeoLib/Grid.h b/GeoLib/Grid.h
index a67254118f75b9af2dd86f2bb0a7ef0988929f97..5691c02b34e5cd8986e21606b0ccb99812139ae2 100644
--- a/GeoLib/Grid.h
+++ b/GeoLib/Grid.h
@@ -49,7 +49,8 @@ public:
      *
      */
     template <typename InputIterator>
-    Grid(InputIterator first, InputIterator last, std::size_t items_per_cell = 512);
+    Grid(InputIterator first, InputIterator last,
+         std::size_t max_num_per_grid_cell = 512);
 
     /**
      * This is the destructor of the class. It deletes the internal data structures *not*
@@ -165,7 +166,7 @@ private:
      */
     template <typename P>
     std::array<double, 6> getPointCellBorderDistances(
-        P const& pnt, std::array<std::size_t,3> const& coordinates) const;
+        P const& pnt, std::array<std::size_t, 3> const& coords) const;
 
     template <typename P>
     bool calcNearestPointInGridCell(P const& pnt,
diff --git a/MaterialLib/Adsorption/Reaction.h b/MaterialLib/Adsorption/Reaction.h
index e5ee5c1d78bcaa638ba2888d358f3a46f1b0006b..213d588abdf270faeb053da5e0c0027ffc17ee7a 100644
--- a/MaterialLib/Adsorption/Reaction.h
+++ b/MaterialLib/Adsorption/Reaction.h
@@ -27,7 +27,10 @@ public:
                                      const double M_Ads, const double loading) const = 0;
 
     // TODO get rid of
-    virtual double getEquilibriumLoading(const double, const double, const double) const {
+    virtual double getEquilibriumLoading(const double /*unused*/,
+                                         const double /*unused*/,
+                                         const double /*unused*/) const
+    {
         return -1.0;
     }
 
diff --git a/MathLib/Integration/WeightedSum.h b/MathLib/Integration/WeightedSum.h
index cbb932d34e8716bdd8d5e531a5c826fb46aa4cfd..947c4a61e5c953fb2aee680131191c55835a9964 100644
--- a/MathLib/Integration/WeightedSum.h
+++ b/MathLib/Integration/WeightedSum.h
@@ -32,9 +32,7 @@ template <typename Method>
 struct SUM<0, Method>
 {
     template <typename F>
-    static
-    double
-    add(F const&)
+    static double add(F const& /*unused*/)
     {
         return 0;
     }
diff --git a/MathLib/LinAlg/Dense/DenseMatrix.h b/MathLib/LinAlg/Dense/DenseMatrix.h
index bfc93604f6de6110fea97bc944dd06208efd1fd9..19ea433ef7a9b145091022464f96a78e7cdf0d97 100644
--- a/MathLib/LinAlg/Dense/DenseMatrix.h
+++ b/MathLib/LinAlg/Dense/DenseMatrix.h
@@ -33,7 +33,7 @@ public:
 
    /// Dense rectangular matrix constructor.
    DenseMatrix (IDX_TYPE rows, IDX_TYPE cols);
-   DenseMatrix (IDX_TYPE rows, IDX_TYPE cols, const FP_TYPE& val);
+   DenseMatrix(IDX_TYPE rows, IDX_TYPE cols, const FP_TYPE& initial_value);
    DenseMatrix (const DenseMatrix &src);
    /**
     * Move constructor.
diff --git a/MathLib/LinAlg/FinalizeMatrixAssembly.h b/MathLib/LinAlg/FinalizeMatrixAssembly.h
index f278275eeeb24b24bf292362a0b6ddcce0c15f12..96fe660c8d814e24dd91b72bedf06d3b3d168ff4 100644
--- a/MathLib/LinAlg/FinalizeMatrixAssembly.h
+++ b/MathLib/LinAlg/FinalizeMatrixAssembly.h
@@ -15,9 +15,8 @@
 
 namespace MathLib
 {
-
 template <typename MAT_T>
-bool finalizeMatrixAssembly(MAT_T &)
+bool finalizeMatrixAssembly(MAT_T& /*unused*/)
 {
     return true;
 }
diff --git a/MathLib/LinAlg/FinalizeVectorAssembly.h b/MathLib/LinAlg/FinalizeVectorAssembly.h
index a1de94eef03510a462e071f7e0da130e4aa4c014..eb47de7741f955b4e71f83ae08ee9d1807a1a60c 100644
--- a/MathLib/LinAlg/FinalizeVectorAssembly.h
+++ b/MathLib/LinAlg/FinalizeVectorAssembly.h
@@ -17,7 +17,7 @@ namespace MathLib
 {
 /// General function to finalize the vector assembly
 template <typename VEC_T>
-void finalizeVectorAssembly(VEC_T &)
+void finalizeVectorAssembly(VEC_T& /*unused*/)
 {
 }
 
diff --git a/MathLib/LinAlg/SetMatrixSparsity.h b/MathLib/LinAlg/SetMatrixSparsity.h
index 3013e9d1c2aad3074a160c092f5c575e75cef070..bbcd1ec0c42102c83ea2fd5caf400f0d09e944f5 100644
--- a/MathLib/LinAlg/SetMatrixSparsity.h
+++ b/MathLib/LinAlg/SetMatrixSparsity.h
@@ -17,8 +17,7 @@ namespace MathLib
 template <typename MATRIX, typename SPARSITY_PATTERN>
 struct SetMatrixSparsity
 {
-    void operator()(MATRIX&, SPARSITY_PATTERN const&)
-    { }
+    void operator()(MATRIX& /*unused*/, SPARSITY_PATTERN const& /*unused*/) {}
 };
 
 /// Sets the sparsity pattern of the underlying matrix.
diff --git a/MeshLib/Elements/HexRule8.h b/MeshLib/Elements/HexRule8.h
index ebf9de650b24903ebb3cc926a49ba0981e5a5df3..001a1476d9d9b0f97395dc285cbbf1f3f4d609f7 100644
--- a/MeshLib/Elements/HexRule8.h
+++ b/MeshLib/Elements/HexRule8.h
@@ -91,7 +91,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six tetrahedra.
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/LineRule2.h b/MeshLib/Elements/LineRule2.h
index d5576eaf76b1b2bb91272f355c42e8690fb151ff..f671d75551778553a021cb10c68b2da030f756fe 100644
--- a/MeshLib/Elements/LineRule2.h
+++ b/MeshLib/Elements/LineRule2.h
@@ -60,7 +60,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[1]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[1]);
 
     /// Calculates the length of a line
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/PointRule1.h b/MeshLib/Elements/PointRule1.h
index 6f4713efcc13c89f45b12dfadf87d0ae2a2738d3..386da78e813487e96b11dfef504c634d3c59925b 100644
--- a/MeshLib/Elements/PointRule1.h
+++ b/MeshLib/Elements/PointRule1.h
@@ -55,7 +55,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[1]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[1]);
 
     /// Calculates the length of a line
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/PrismRule6.h b/MeshLib/Elements/PrismRule6.h
index 5e93fa003f4dc93dc8b81e45133174f129dcc34b..0682a5d5e28f7113f4014813d835a37bc1f62ee7 100644
--- a/MeshLib/Elements/PrismRule6.h
+++ b/MeshLib/Elements/PrismRule6.h
@@ -92,7 +92,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six tetrahedra.
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/PyramidRule5.h b/MeshLib/Elements/PyramidRule5.h
index bdf2c0f941208718113c8e437785e0ada0d9857a..c40dd3d96bc2eabb80e5c2a836c7c18b1afdf6a8 100644
--- a/MeshLib/Elements/PyramidRule5.h
+++ b/MeshLib/Elements/PyramidRule5.h
@@ -91,7 +91,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six tetrahedra.
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/QuadRule4.h b/MeshLib/Elements/QuadRule4.h
index 8a78c7a62ab8e0a6bfd21b912ca8c65958c36cc9..eb10d5df9f91ca9793b2781720baa3655920897d 100644
--- a/MeshLib/Elements/QuadRule4.h
+++ b/MeshLib/Elements/QuadRule4.h
@@ -73,7 +73,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six tetrahedra.
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/TetRule4.h b/MeshLib/Elements/TetRule4.h
index 76ac9ac5930eedc03df275885900219b537b79ac..de46bf4ec99ad278b097bb78e53c2e275e8fdd16 100644
--- a/MeshLib/Elements/TetRule4.h
+++ b/MeshLib/Elements/TetRule4.h
@@ -86,7 +86,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of the element
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Elements/TriRule3.h b/MeshLib/Elements/TriRule3.h
index 67178beb3acb9d4da378fcf7e9da93b44d0686b1..56f000799292f13a724177ef5f338e43b29b4651 100644
--- a/MeshLib/Elements/TriRule3.h
+++ b/MeshLib/Elements/TriRule3.h
@@ -74,7 +74,7 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const*, Node* nodes[3]);
+    static unsigned identifyFace(Node const* const* /*_nodes*/, Node* nodes[3]);
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six tetrahedra.
     static double computeVolume(Node const* const* _nodes);
diff --git a/MeshLib/Properties.h b/MeshLib/Properties.h
index 7eb20426a596b311f6412f5c4e03320246b53432..efb465ad3b3df4068335c1ab6357949c1b04ffbc 100644
--- a/MeshLib/Properties.h
+++ b/MeshLib/Properties.h
@@ -116,7 +116,7 @@ public:
     template <typename T>
     PropertyVector<T>* getPropertyVector(std::string const& name,
                                          MeshItemType const item_type,
-                                         int const number_of_components);
+                                         int const n_components);
 
     void removePropertyVector(std::string const& name);
 
diff --git a/MeshLib/Vtk/VtkMappedMeshSource.h b/MeshLib/Vtk/VtkMappedMeshSource.h
index 05e04784cfcd157f51efcb12dddcec39416cf2a7..613d8577037e7efc328e1ec463aa2d6c4322e439 100644
--- a/MeshLib/Vtk/VtkMappedMeshSource.h
+++ b/MeshLib/Vtk/VtkMappedMeshSource.h
@@ -67,10 +67,12 @@ protected:
     int ProcessRequest(vtkInformation* request,
                        vtkInformationVector** inputVector,
                        vtkInformationVector* outputVector) override;
-    int RequestData(vtkInformation*, vtkInformationVector**,
-                    vtkInformationVector*) override;
-    int RequestInformation(vtkInformation*, vtkInformationVector**,
-                           vtkInformationVector*) override;
+    int RequestData(vtkInformation* /*request*/,
+                    vtkInformationVector** /*inputVector*/,
+                    vtkInformationVector* /*outputVector*/) override;
+    int RequestInformation(vtkInformation* /*request*/,
+                           vtkInformationVector** /*inputVector*/,
+                           vtkInformationVector* /*outputVector*/) override;
 
 private:
     /// Adds a zero-copy vtk array wrapper.
diff --git a/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate-impl.h b/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate-impl.h
index 39a659db6eda51c3bf607c17b788141e43d3baba..791a3c74c67efabb2f3271b76032dc0d66b91430 100644
--- a/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate-impl.h
+++ b/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate-impl.h
@@ -201,99 +201,113 @@ template <class Scalar> Scalar& VtkMeshNodalCoordinatesTemplate<Scalar>
     return (*(*this->_nodes)[tuple])[comp];
 }
 
-template <class Scalar> int VtkMeshNodalCoordinatesTemplate<Scalar>
-::Allocate(vtkIdType, vtkIdType)
+template <class Scalar>
+int VtkMeshNodalCoordinatesTemplate<Scalar>::Allocate(vtkIdType /*unused*/,
+                                                      vtkIdType /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return 0;
 }
 
-template <class Scalar> int VtkMeshNodalCoordinatesTemplate<Scalar>
-::Resize(vtkIdType)
+template <class Scalar>
+int VtkMeshNodalCoordinatesTemplate<Scalar>::Resize(vtkIdType /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return 0;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetNumberOfTuples(vtkIdType)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetNumberOfTuples(
+    vtkIdType /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetTuple(vtkIdType, vtkIdType, vtkAbstractArray *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetTuple(
+    vtkIdType /*unused*/, vtkIdType /*unused*/, vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetTuple(vtkIdType, const float *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetTuple(vtkIdType /*unused*/,
+                                                       const float* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetTuple(vtkIdType, const double *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetTuple(vtkIdType /*unused*/,
+                                                       const double* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTuple(vtkIdType, vtkIdType, vtkAbstractArray *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTuple(
+    vtkIdType /*unused*/, vtkIdType /*unused*/, vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTuple(vtkIdType, const float *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTuple(
+    vtkIdType /*unused*/, const float* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTuple(vtkIdType, const double *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTuple(
+    vtkIdType /*unused*/, const double* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTuples(vtkIdList *, vtkIdList *, vtkAbstractArray *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTuples(
+    vtkIdList* /*unused*/, vtkIdList* /*unused*/, vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTuples(vtkIdType, vtkIdType, vtkIdType, vtkAbstractArray*)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTuples(
+    vtkIdType /*unused*/, vtkIdType /*unused*/, vtkIdType /*unused*/,
+    vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertNextTuple(vtkIdType, vtkAbstractArray *)
+template <class Scalar>
+vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>::InsertNextTuple(
+    vtkIdType /*unused*/, vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return -1;
 }
 
-template <class Scalar> vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertNextTuple(const float *)
+template <class Scalar>
+vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>::InsertNextTuple(
+    const float* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return -1;
 }
 
-template <class Scalar> vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertNextTuple(const double *)
+template <class Scalar>
+vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>::InsertNextTuple(
+    const double* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return -1;
@@ -305,44 +319,49 @@ template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
     vtkErrorMacro("Read only container.");
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::DeepCopy(vtkAbstractArray *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::DeepCopy(
+    vtkAbstractArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::DeepCopy(vtkDataArray *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::DeepCopy(vtkDataArray* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InterpolateTuple(vtkIdType, vtkIdList *, vtkAbstractArray *, double *)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InterpolateTuple(
+    vtkIdType /*unused*/, vtkIdList* /*unused*/, vtkAbstractArray* /*unused*/,
+    double* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InterpolateTuple(vtkIdType, vtkIdType, vtkAbstractArray*, vtkIdType,
-                   vtkAbstractArray*, double)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InterpolateTuple(
+    vtkIdType /*unused*/, vtkIdType /*unused*/, vtkAbstractArray* /*unused*/,
+    vtkIdType /*unused*/, vtkAbstractArray* /*unused*/, double /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetVariantValue(vtkIdType, vtkVariant)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetVariantValue(
+    vtkIdType /*unused*/, vtkVariant /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::RemoveTuple(vtkIdType)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::RemoveTuple(vtkIdType /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
@@ -362,22 +381,25 @@ template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetValue(vtkIdType, Scalar)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetValue(vtkIdType /*unused*/,
+                                                       Scalar /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertNextValue(Scalar)
+template <class Scalar>
+vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>::InsertNextValue(
+    Scalar /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return -1;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertValue(vtkIdType, Scalar)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertValue(vtkIdType /*unused*/,
+                                                          Scalar /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
@@ -430,22 +452,25 @@ template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
     tuple[2] = (*(*this->_nodes)[tupleId])[2];
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::SetTypedTuple(vtkIdType, const Scalar*)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::SetTypedTuple(
+    vtkIdType /*unused*/, const Scalar* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> void VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertTypedTuple(vtkIdType, const Scalar*)
+template <class Scalar>
+void VtkMeshNodalCoordinatesTemplate<Scalar>::InsertTypedTuple(
+    vtkIdType /*unused*/, const Scalar* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return;
 }
 
-template <class Scalar> vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>
-::InsertNextTypedTuple(const Scalar *)
+template <class Scalar>
+vtkIdType VtkMeshNodalCoordinatesTemplate<Scalar>::InsertNextTypedTuple(
+    const Scalar* /*unused*/)
 {
     vtkErrorMacro("Read only container.");
     return -1;
diff --git a/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate.h b/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate.h
index 45d0eb6ba298e9ace2e31454f5de342db89c990a..cc5e9bc6856c856e4b2c2014c40f9fd9da91ce32 100644
--- a/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate.h
+++ b/MeshLib/Vtk/VtkMeshNodalCoordinatesTemplate.h
@@ -81,7 +81,9 @@ public:
     void InsertTuple(vtkIdType i, const double *source) override;
     void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
                       vtkAbstractArray *source) override;
-    void InsertTuples(vtkIdType, vtkIdType, vtkIdType, vtkAbstractArray*) override;
+    void InsertTuples(vtkIdType /*unused*/, vtkIdType /*unused*/,
+                      vtkIdType /*unused*/,
+                      vtkAbstractArray* /*unused*/) override;
     vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray *source) override;
     vtkIdType InsertNextTuple(const float *source) override;
     vtkIdType InsertNextTuple(const double *source) override;
@@ -103,7 +105,7 @@ public:
 #if !(VTK_MAJOR_VERSION < 7 || VTK_MAJOR_VERSION == 7 && VTK_MINOR_VERSION < 1)
     Scalar& GetValueReference(vtkIdType idx) const;
     Scalar GetValue(vtkIdType idx) const override;
-    void GetTypedTuple(vtkIdType idx, Scalar* t) const override;
+    void GetTypedTuple(vtkIdType tupleId, Scalar* t) const override;
     void SetTypedTuple(vtkIdType i, const Scalar* t) override;
     void InsertTypedTuple(vtkIdType i, const Scalar* t) override;
     vtkIdType InsertNextTypedTuple(const Scalar* t) override;
diff --git a/NumLib/DOF/LocalToGlobalIndexMap.h b/NumLib/DOF/LocalToGlobalIndexMap.h
index 50d3602016b54becf33cd7eb16b3aee4dc4a08b2..6795460a08037b3c411c5f6bcca28c3039582568 100644
--- a/NumLib/DOF/LocalToGlobalIndexMap.h
+++ b/NumLib/DOF/LocalToGlobalIndexMap.h
@@ -174,7 +174,8 @@ public:
         std::vector<int> const& global_component_ids,
         std::vector<int> const& variable_component_offsets,
         std::vector<MeshLib::Element*> const& elements,
-        NumLib::MeshComponentMap&& mesh_component_map, ConstructorTag);
+        NumLib::MeshComponentMap&& mesh_component_map,
+        ConstructorTag /*unused*/);
 
 private:
     template <typename ElementIterator>
diff --git a/NumLib/Fem/CoordinatesMapping/ShapeMatrices-impl.h b/NumLib/Fem/CoordinatesMapping/ShapeMatrices-impl.h
index e3ef9f6eb83e79a0ea15d7b6b5cef1e439a058d6..e6c8810d219ec3387a12636c23d91b9eea2a34db 100644
--- a/NumLib/Fem/CoordinatesMapping/ShapeMatrices-impl.h
+++ b/NumLib/Fem/CoordinatesMapping/ShapeMatrices-impl.h
@@ -50,19 +50,22 @@ void setVectorZero(T &vec)
 template <ShapeMatrixType FIELD_TYPE> struct ShapeDataFieldType {};
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::N>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::N> /*unused*/)
 {
     setVectorZero(shape.N);
 }
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::DNDR>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::DNDR> /*unused*/)
 {
     setMatrixZero(shape.dNdr);
 }
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::DNDR_J>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::DNDR_J> /*unused*/)
 {
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR>());
     setMatrixZero(shape.J);
@@ -71,14 +74,16 @@ inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFie
 }
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::N_J>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::N_J> /*unused*/)
 {
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::N>());
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR_J>());
 }
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::DNDX>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::DNDX> /*unused*/)
 {
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR_J>());
     setMatrixZero(shape.invJ);
@@ -86,7 +91,8 @@ inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFie
 }
 
 template <class T_N, class T_DNDR, class T_J, class T_DNDX>
-inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX> &shape, ShapeDataFieldType<ShapeMatrixType::ALL>)
+inline void setZero(ShapeMatrices<T_N, T_DNDR, T_J, T_DNDX>& shape,
+                    ShapeDataFieldType<ShapeMatrixType::ALL> /*unused*/)
 {
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::N>());
     setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDX>());
diff --git a/NumLib/Fem/ShapeFunction/ShapePrism15.h b/NumLib/Fem/ShapeFunction/ShapePrism15.h
index 26dab800d4bb7e728a146c231b6d5c26adc14882..1fc4f8abe69255368b7de16a9eedf601714fbc89 100644
--- a/NumLib/Fem/ShapeFunction/ShapePrism15.h
+++ b/NumLib/Fem/ShapeFunction/ShapePrism15.h
@@ -28,7 +28,7 @@ public:
      * @param [out] N   a vector of calculated shape functions
      */
     template <class T_X, class T_N>
-    static void computeShapeFunction(const T_X &r, T_N &N);
+    static void computeShapeFunction(const T_X& x, T_N& N);
 
     /**
      * Evaluate derivatives of the shape function at the given point
@@ -37,7 +37,7 @@ public:
      * @param [out] dN  a matrix of the derivatives
      */
     template <class T_X, class T_N>
-    static void computeGradShapeFunction(const T_X &r, T_N &dN);
+    static void computeGradShapeFunction(const T_X& x, T_N& dN);
 
     using MeshElement = MeshLib::Prism15;
     static const unsigned DIM = MeshElement::dimension;
diff --git a/NumLib/Fem/ShapeFunction/ShapePrism6.h b/NumLib/Fem/ShapeFunction/ShapePrism6.h
index 12dd8456be5b1d9ac83b7f883ce7143f0ef8974a..fd392232aed793f51969a8706884e960c4c30a5e 100644
--- a/NumLib/Fem/ShapeFunction/ShapePrism6.h
+++ b/NumLib/Fem/ShapeFunction/ShapePrism6.h
@@ -28,7 +28,7 @@ public:
      * @param [out] N   a vector of calculated shape functions
      */
     template <class T_X, class T_N>
-    static void computeShapeFunction(const T_X &r, T_N &N);
+    static void computeShapeFunction(const T_X& x, T_N& N);
 
     /**
      * Evaluate derivatives of the shape function at the given point
@@ -37,7 +37,7 @@ public:
      * @param [out] dN  a matrix of the derivatives
      */
     template <class T_X, class T_N>
-    static void computeGradShapeFunction(const T_X &r, T_N &dN);
+    static void computeGradShapeFunction(const T_X& x, T_N& dN);
 
     using MeshElement = MeshLib::Prism;
     static const unsigned DIM = MeshElement::dimension;
diff --git a/NumLib/Fem/ShapeFunction/ShapePyra13.h b/NumLib/Fem/ShapeFunction/ShapePyra13.h
index d66f49fac800488a1e7e81d3baa32771b9f3bbd2..8c7446fd7a740a0158fcb0ba3d3a54ac52287b1a 100644
--- a/NumLib/Fem/ShapeFunction/ShapePyra13.h
+++ b/NumLib/Fem/ShapeFunction/ShapePyra13.h
@@ -28,7 +28,7 @@ public:
      * @param [out] N   a vector of calculated shape functions
      */
     template <class T_X, class T_N>
-    static void computeShapeFunction(const T_X &r, T_N &N);
+    static void computeShapeFunction(const T_X& x, T_N& N);
 
     /**
      * Evaluate derivatives of the shape function at the given point
@@ -37,7 +37,7 @@ public:
      * @param [out] dN  a matrix of the derivatives
      */
     template <class T_X, class T_N>
-    static void computeGradShapeFunction(const T_X &r, T_N &dN);
+    static void computeGradShapeFunction(const T_X& x, T_N& dN);
 
     using MeshElement = MeshLib::Pyramid13;
     static const unsigned DIM = MeshElement::dimension;
diff --git a/NumLib/Fem/ShapeFunction/ShapePyra5.h b/NumLib/Fem/ShapeFunction/ShapePyra5.h
index 2bd1fd5a52566efbd0fe70d383bc5908f646df1c..50d56e71161b8b3fc9c876f34e7afeb7a893ba2c 100644
--- a/NumLib/Fem/ShapeFunction/ShapePyra5.h
+++ b/NumLib/Fem/ShapeFunction/ShapePyra5.h
@@ -28,7 +28,7 @@ public:
      * @param [out] N   a vector of calculated shape functions
      */
     template <class T_X, class T_N>
-    static void computeShapeFunction(const T_X &r, T_N &N);
+    static void computeShapeFunction(const T_X& x, T_N& N);
 
     /**
      * Evaluate derivatives of the shape function at the given point
@@ -37,7 +37,7 @@ public:
      * @param [out] dN  a matrix of the derivatives
      */
     template <class T_X, class T_N>
-    static void computeGradShapeFunction(const T_X &r, T_N &dN);
+    static void computeGradShapeFunction(const T_X& x, T_N& dN);
 
     using MeshElement = MeshLib::Pyramid;
     static const unsigned DIM = MeshElement::dimension;
diff --git a/NumLib/NamedFunction.h b/NumLib/NamedFunction.h
index 80100218dfff3a601133f700b728ed6d8a96cd07..d415bc8f66bc65e05da50c30191ed90832834c3c 100644
--- a/NumLib/NamedFunction.h
+++ b/NumLib/NamedFunction.h
@@ -63,7 +63,7 @@ public:
                   std::function<ReturnType(Arguments...)>&& function);
 
     NamedFunction(NamedFunction&& other);
-    NamedFunction(NamedFunction const&);
+    NamedFunction(NamedFunction const& other);
 
     ~NamedFunction();
 
diff --git a/NumLib/ODESolver/TimeDiscretization.h b/NumLib/ODESolver/TimeDiscretization.h
index 8bf113f9281e9d12190a3a79aca44acd170ae53f..9694ad7749375ffe34e201ba232d841ade678682 100644
--- a/NumLib/ODESolver/TimeDiscretization.h
+++ b/NumLib/ODESolver/TimeDiscretization.h
@@ -269,7 +269,7 @@ public:
         GlobalVector const& x, MathLib::VecNormType norm_type) override;
 
     void pushState(const double /*t*/, GlobalVector const& x,
-                   InternalMatrixStorage const&) override
+                   InternalMatrixStorage const& /*strg*/) override
     {
         MathLib::LinAlg::copy(x, _x_old);
     }
@@ -327,7 +327,7 @@ public:
         GlobalVector const& x, MathLib::VecNormType norm_type) override;
 
     void pushState(const double /*t*/, GlobalVector const& x,
-                   InternalMatrixStorage const&) override
+                   InternalMatrixStorage const& /*strg*/) override
     {
         MathLib::LinAlg::copy(x, _x_old);
     }
@@ -411,7 +411,7 @@ public:
     double getRelativeChangeFromPreviousTimestep(
         GlobalVector const& x, MathLib::VecNormType norm_type) override;
 
-    void pushState(const double, GlobalVector const& x,
+    void pushState(const double /*t*/, GlobalVector const& x,
                    InternalMatrixStorage const& strg) override
     {
         MathLib::LinAlg::copy(x, _x_old);
@@ -494,8 +494,8 @@ public:
     double getRelativeChangeFromPreviousTimestep(
         GlobalVector const& x, MathLib::VecNormType norm_type) override;
 
-    void pushState(const double, GlobalVector const& x,
-                   InternalMatrixStorage const&) override;
+    void pushState(const double /*t*/, GlobalVector const& x,
+                   InternalMatrixStorage const& /*strg*/) override;
 
     void popState(GlobalVector& x) override
     {
diff --git a/ParameterLib/GroupBasedParameter.h b/ParameterLib/GroupBasedParameter.h
index 71d9d979cdfcba3fa5d18f21c107f9771e5059ae..f0064d1e96ad05458b49e8882dd15b9f4de4e4cc 100644
--- a/ParameterLib/GroupBasedParameter.h
+++ b/ParameterLib/GroupBasedParameter.h
@@ -84,13 +84,15 @@ private:
     };
 
     static boost::optional<std::size_t> getMeshItemID(
-        SpatialPosition const& pos, type<MeshLib::MeshItemType::Cell>)
+        SpatialPosition const& pos,
+        type<MeshLib::MeshItemType::Cell> /*unused*/)
     {
         return pos.getElementID();
     }
 
     static boost::optional<std::size_t> getMeshItemID(
-        SpatialPosition const& pos, type<MeshLib::MeshItemType::Node>)
+        SpatialPosition const& pos,
+        type<MeshLib::MeshItemType::Node> /*unused*/)
     {
         return pos.getNodeID();
     }
diff --git a/ProcessLib/HydroMechanics/LocalDataInitializer.h b/ProcessLib/HydroMechanics/LocalDataInitializer.h
index 123de39a53c53672309c6e72ce3bcf00cb2619ac..0c32fd94ae01102b60465655b81b8038e95ec12d 100644
--- a/ProcessLib/HydroMechanics/LocalDataInitializer.h
+++ b/ProcessLib/HydroMechanics/LocalDataInitializer.h
@@ -255,7 +255,7 @@ private:
     /// 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         // (Lower order elements = Order(ShapeFunctionDisplacement) - 1).
         using ShapeFunctionPressure =
@@ -273,7 +273,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/LIE/HydroMechanics/LocalAssembler/HydroMechanicsLocalAssemblerMatrixNearFracture.h b/ProcessLib/LIE/HydroMechanics/LocalAssembler/HydroMechanicsLocalAssemblerMatrixNearFracture.h
index be07a6d3fbd7eb0179d5fcda6fcc9c08b4aed364..c44c76d63e2b2c4d56302eeb7789d8b3dbfb213b 100644
--- a/ProcessLib/LIE/HydroMechanics/LocalAssembler/HydroMechanicsLocalAssemblerMatrixNearFracture.h
+++ b/ProcessLib/LIE/HydroMechanics/LocalAssembler/HydroMechanicsLocalAssemblerMatrixNearFracture.h
@@ -55,8 +55,8 @@ public:
 
 private:
     void assembleWithJacobianConcrete(double const t,
-                                      Eigen::VectorXd const& local_u,
-                                      Eigen::VectorXd const& local_udot,
+                                      Eigen::VectorXd const& local_x,
+                                      Eigen::VectorXd const& local_x_dot,
                                       Eigen::VectorXd& local_b,
                                       Eigen::MatrixXd& local_J) override;
 
diff --git a/ProcessLib/LIE/HydroMechanics/LocalAssembler/LocalDataInitializer.h b/ProcessLib/LIE/HydroMechanics/LocalAssembler/LocalDataInitializer.h
index 106070878f6268c7ea04438965eb7046b365a46d..ed9fa66adf58090a742a92c1ebeb1da700adbae5 100644
--- a/ProcessLib/LIE/HydroMechanics/LocalAssembler/LocalDataInitializer.h
+++ b/ProcessLib/LIE/HydroMechanics/LocalAssembler/LocalDataInitializer.h
@@ -339,7 +339,7 @@ private:
     /// 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         // (Lower order elements = Order(ShapeFunctionDisplacement) - 1).
         using ShapeFunctionPressure =
@@ -375,7 +375,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/LIE/SmallDeformation/LocalAssembler/LocalDataInitializer.h b/ProcessLib/LIE/SmallDeformation/LocalAssembler/LocalDataInitializer.h
index bd64e20df2292132f892a9ba2b23005092eff400..f02a619189c34e45db88d90bf062236524683181 100644
--- a/ProcessLib/LIE/SmallDeformation/LocalAssembler/LocalDataInitializer.h
+++ b/ProcessLib/LIE/SmallDeformation/LocalAssembler/LocalDataInitializer.h
@@ -343,7 +343,7 @@ private:
     /// combinations of shape functions and global dimensions: (Line2, 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         return [](MeshLib::Element const& e,
                   std::size_t const n_variables,
@@ -374,7 +374,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/LIE/SmallDeformation/LocalAssembler/SmallDeformationLocalAssemblerFracture.h b/ProcessLib/LIE/SmallDeformation/LocalAssembler/SmallDeformationLocalAssemblerFracture.h
index 9174300f014a4dc0f9345bea63c20dab6b092a38..8df89c26179775fc76da200ec4b9867de6aa317e 100644
--- a/ProcessLib/LIE/SmallDeformation/LocalAssembler/SmallDeformationLocalAssemblerFracture.h
+++ b/ProcessLib/LIE/SmallDeformation/LocalAssembler/SmallDeformationLocalAssemblerFracture.h
@@ -92,7 +92,7 @@ public:
     }
 
     void computeSecondaryVariableConcreteWithVector(
-        const double t, Eigen::VectorXd const& local_x) override;
+        const double t, Eigen::VectorXd const& local_u) override;
 
     Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
         const unsigned integration_point) const override
diff --git a/ProcessLib/ProcessVariable.h b/ProcessLib/ProcessVariable.h
index 30b374aa60b0152d5c95e30ab4fcaa0c4787ec84..23838df06f432f8abdafe25611b57b46611dbf5b 100644
--- a/ProcessLib/ProcessVariable.h
+++ b/ProcessLib/ProcessVariable.h
@@ -51,7 +51,7 @@ public:
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
             parameters);
 
-    ProcessVariable(ProcessVariable&&);
+    ProcessVariable(ProcessVariable&& other);
 
     std::string const& getName() const;
 
diff --git a/ProcessLib/RichardsMechanics/LocalDataInitializer.h b/ProcessLib/RichardsMechanics/LocalDataInitializer.h
index b6a4eb63db8b809d70a36e6d28a5804631c13c97..8f3dafe35a446c5afc7cc4b9d3b3220fc7f7d967 100644
--- a/ProcessLib/RichardsMechanics/LocalDataInitializer.h
+++ b/ProcessLib/RichardsMechanics/LocalDataInitializer.h
@@ -255,7 +255,7 @@ private:
     /// 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         // (Lower order elements = Order(ShapeFunctionDisplacement) - 1).
         using ShapeFunctionPressure =
@@ -273,7 +273,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/SmallDeformation/LocalDataInitializer.h b/ProcessLib/SmallDeformation/LocalDataInitializer.h
index a266324c43e692277a03985249eab736f7afd04e..47ef8894f02b51d3c79183fc559d210a82076742 100644
--- a/ProcessLib/SmallDeformation/LocalDataInitializer.h
+++ b/ProcessLib/SmallDeformation/LocalDataInitializer.h
@@ -274,7 +274,7 @@ private:
     /// combinations of shape functions and global dimensions: (Line2, 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         return [](MeshLib::Element const& e,
                   std::size_t const local_matrix_size,
@@ -287,7 +287,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/TES/TESReactionAdaptor.h b/ProcessLib/TES/TESReactionAdaptor.h
index 331c64bea242b21e55aa64cee1cc44d51a3316d0..a2c6a2b51c922f84444c67a2e72987fbd3e0c780 100644
--- a/ProcessLib/TES/TESReactionAdaptor.h
+++ b/ProcessLib/TES/TESReactionAdaptor.h
@@ -86,7 +86,7 @@ private:
 class TESFEMReactionAdaptorInert final : public TESFEMReactionAdaptor
 {
 public:
-    explicit TESFEMReactionAdaptorInert(TESLocalAssemblerData const&);
+    explicit TESFEMReactionAdaptorInert(TESLocalAssemblerData const& /*data*/);
 
     ReactionRate initReaction(const unsigned int_pt) override;
 
@@ -99,7 +99,7 @@ class TESFEMReactionAdaptorSinusoidal final : public TESFEMReactionAdaptor
 public:
     explicit TESFEMReactionAdaptorSinusoidal(TESLocalAssemblerData const& data);
 
-    ReactionRate initReaction(const unsigned) override;
+    ReactionRate initReaction(const unsigned /*int_pt*/) override;
 
 private:
     TESLocalAssemblerData const& _d;
@@ -110,7 +110,7 @@ class TESFEMReactionAdaptorCaOH2 final : public TESFEMReactionAdaptor
 public:
     explicit TESFEMReactionAdaptorCaOH2(TESLocalAssemblerData const& data);
 
-    ReactionRate initReaction(const unsigned) override;
+    ReactionRate initReaction(const unsigned /*int_pt*/) override;
 
 private:
     using Data = TESLocalAssemblerData;
diff --git a/ProcessLib/ThermoHydroMechanics/LocalDataInitializer.h b/ProcessLib/ThermoHydroMechanics/LocalDataInitializer.h
index f8801c2b3315c5c69a4f8719fb7aeb81870c6069..b624e5c15008db4d560ab57a409cf088e2291cad 100644
--- a/ProcessLib/ThermoHydroMechanics/LocalDataInitializer.h
+++ b/ProcessLib/ThermoHydroMechanics/LocalDataInitializer.h
@@ -254,7 +254,7 @@ private:
     /// 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         // (Lower order elements = Order(ShapeFunctionDisplacement) - 1).
         using ShapeFunctionPressure =
@@ -272,7 +272,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunctionDisplacement>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/ProcessLib/Utils/LocalDataInitializer.h b/ProcessLib/Utils/LocalDataInitializer.h
index e51b329c2c947e99f38df39b71bd3cddf38bd157..f368b986cf8eb1f7ea18911a8eff5e352fdf2e5d 100644
--- a/ProcessLib/Utils/LocalDataInitializer.h
+++ b/ProcessLib/Utils/LocalDataInitializer.h
@@ -371,7 +371,7 @@ private:
     /// combinations of shape functions and global dimensions: (Line2, 1),
     /// (Line2, 2), (Line2, 3), (Hex20, 3) but not (Hex20, 2) or (Hex20, 1).
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::true_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::true_type* /*unused*/)
     {
         return [](MeshLib::Element const& e,
                   std::size_t const local_matrix_size,
@@ -384,7 +384,7 @@ private:
     /// Returns nullptr for shape functions whose dimensions are less than the
     /// global dimension.
     template <typename ShapeFunction>
-    static LADataBuilder makeLocalAssemblerBuilder(std::false_type*)
+    static LADataBuilder makeLocalAssemblerBuilder(std::false_type* /*unused*/)
     {
         return nullptr;
     }
diff --git a/Tests/AutoCheckTools.h b/Tests/AutoCheckTools.h
index f28ebd5ab2ddeb8ff754c434591162257e9e3806..03aec6d7fa0c444d9fd52b389675496e612a28a0 100644
--- a/Tests/AutoCheckTools.h
+++ b/Tests/AutoCheckTools.h
@@ -122,13 +122,10 @@ struct randomCoordinateIndexGenerator
     Gen source;
     using result_type = T;
 
-    result_type operator()(std::size_t)
-    {
-        return source() % DIM;
-    }
+    result_type operator()(std::size_t /*unused*/) { return source() % DIM; }
 };
 
-inline double absoluteValue(double&& v, std::size_t)
+inline double absoluteValue(double&& v, std::size_t /*unused*/)
 {
     return std::abs(v);
 }
diff --git a/Tests/InstanceCounter.h b/Tests/InstanceCounter.h
index b1fa755a4663b067241ac2093aa137c551d0ac5a..50a22b2473f2dd706c4e134149bb2c7e5a3be3cd 100644
--- a/Tests/InstanceCounter.h
+++ b/Tests/InstanceCounter.h
@@ -16,12 +16,8 @@ public:
     InstanceCounter() {
         ++_num_constructed;
     }
-    InstanceCounter(InstanceCounter<T> const&) {
-        ++_num_copied;
-    }
-    InstanceCounter(InstanceCounter<T>&&) {
-        ++_num_moved;
-    }
+    InstanceCounter(InstanceCounter<T> const& /*unused*/) { ++_num_copied; }
+    InstanceCounter(InstanceCounter<T>&& /*unused*/) { ++_num_moved; }
     virtual ~InstanceCounter() {
         ++_num_destroyed;
     }
diff --git a/Tests/NumLib/SteadyDiffusion2DExample1.h b/Tests/NumLib/SteadyDiffusion2DExample1.h
index d8f91bc10ed87b0f43055d9a7807c700c825ac7f..b89f4d5d4bf0614d0de5b0a11ab493b56a4cf3f7 100644
--- a/Tests/NumLib/SteadyDiffusion2DExample1.h
+++ b/Tests/NumLib/SteadyDiffusion2DExample1.h
@@ -31,10 +31,10 @@ template<typename IndexType>struct SteadyDiffusion2DExample1
     class LocalAssemblerData
     {
     public:
-        void init(MeshLib::Element const&,
-            std::size_t const /*local_matrix_size*/,
-            LocalMatrixType const& localA,
-            LocalVectorType const& localRhs)
+        void init(MeshLib::Element const& /*unused*/,
+                  std::size_t const /*local_matrix_size*/,
+                  LocalMatrixType const& localA,
+                  LocalVectorType const& localRhs)
         {
             _localA = &localA;
             _localRhs = &localRhs;