diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive.hh
index 4c29e36d4..7fa178a28 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive.hh
@@ -1,116 +1,115 @@
 /**
  * @file   ntn_friclaw_linear_cohesive.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  linear cohesive law
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AST_NTN_FRICLAW_LINEAR_COHESIVE_HH_
 #define AST_NTN_FRICLAW_LINEAR_COHESIVE_HH_
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_fricreg_no_regularisation.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation = NTNFricRegNoRegularisation>
 class NTNFricLawLinearCohesive : public Regularisation {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   NTNFricLawLinearCohesive(NTNBaseContact & contact,
                            const ID & id = "linear_cohesive");
   ~NTNFricLawLinearCohesive() override = default;
-  ;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// register synchronizedarrays for sync
   void registerSynchronizedArray(SynchronizedArrayBase & array) override;
 
   /// dump restart file
   void dumpRestart(const std::string & file_name) const override;
 
   /// read restart file
   void readRestart(const std::string & file_name) override;
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
 protected:
   /// compute frictional strength according to friction law
   void computeFrictionalStrength() override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   void addDumpFieldToDumper(const std::string & dumper_name,
                             const std::string & field_id) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   // fracture energy
   SynchronizedArray<Real> G_c;
 
   // peak value of cohesive law
   SynchronizedArray<Real> tau_c;
 
   // residual value of cohesive law (for slip > d_c)
   SynchronizedArray<Real> tau_r;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 template <class Regularisation>
 inline std::ostream &
 operator<<(std::ostream & stream,
            const NTNFricLawLinearCohesive<Regularisation> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "ntn_friclaw_linear_cohesive_tmpl.hh"
 
 #endif /* AST_NTN_FRICLAW_LINEAR_COHESIVE_HH_ */
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.hh
index 9e90e2945..f23eec34d 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.hh
@@ -1,103 +1,102 @@
 /**
  * @file   ntn_fricreg_rubin_ampuero.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  regularisation that regularizes the contact pressure
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AST_NTN_FRICREG_RUBIN_AMPUERO_HH_
 #define AST_NTN_FRICREG_RUBIN_AMPUERO_HH_
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_fricreg_no_regularisation.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class NTNFricRegRubinAmpuero : public NTNFricRegNoRegularisation {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   NTNFricRegRubinAmpuero(NTNBaseContact & contact,
                          const ID & id = "rubin_ampuero");
   ~NTNFricRegRubinAmpuero() override = default;
-  ;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void registerSynchronizedArray(SynchronizedArrayBase & array) override;
   void dumpRestart(const std::string & file_name) const override;
   void readRestart(const std::string & file_name) override;
 
   void setToSteadyState() override;
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   void addDumpFieldToDumper(const std::string & dumper_name,
                             const std::string & field_id) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 protected:
   /// get the contact pressure (the norm: scalar value)
   const SynchronizedArray<Real> & internalGetContactPressure() override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   SynchronizedArray<Real> t_star;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "ntn_fricreg_rubin_ampuero_inline_impl.hh"
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const NTNFricRegRubinAmpuero & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* AST_NTN_FRICREG_RUBIN_AMPUERO_HH_ */
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_friction.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_friction.hh
index aae2501f0..82cf47e17 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_friction.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_friction.hh
@@ -1,101 +1,100 @@
 /**
  * @file   ntn_friction.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  implementation of friction for node to node contact
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef AST_NTN_FRICTION_HH_
 #define AST_NTN_FRICTION_HH_
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_base_friction.hh"
 #include "ntn_friclaw_coulomb.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class FrictionLaw = NTNFricLawCoulomb,
           class Regularisation = NTNFricRegNoRegularisation>
 class NTNFriction : public FrictionLaw<Regularisation> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   NTNFriction(NTNBaseContact & contact, const ID & id = "friction");
   ~NTNFriction() override = default;
-  ;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// apply the friction force
   void applyFrictionTraction() override;
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
 protected:
   /* ------------------------------------------------------------------------ */
   /* Dumpable                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   // virtual void addDumpFieldToDumper(const std::string & dumper_name,
   // 				    const std::string & field_id);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 template <template <class> class FrictionLaw, class Regularisation>
 inline std::ostream &
 operator<<(std::ostream & stream,
            const NTNFriction<FrictionLaw, Regularisation> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "ntn_friction_tmpl.hh"
 
 #endif /* AST_NTN_FRICTION_HH_ */
diff --git a/src/model/contact_mechanics/contact_element.hh b/src/model/contact_mechanics/contact_element.hh
index 040c158df..b97ae3c7d 100644
--- a/src/model/contact_mechanics/contact_element.hh
+++ b/src/model/contact_mechanics/contact_element.hh
@@ -1,86 +1,87 @@
 /**
  * @file   contact_element.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Tue Jun 08 2021
  *
  * @brief  Mother class for all detection algorithms
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "element.hh"
+#include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_CONTACT_ELEMENT_HH__
 #define __AKANTU_CONTACT_ELEMENT_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 using SlaveType = UInt;
 using MasterType = Element;
 
 class ContactElement {
 
   /* ------------------------------------------------------------------------ */
   /* Constructor/ Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ContactElement() = default;
 
   ContactElement(const SlaveType & slave, const MasterType & master)
       : slave(slave), master(master) {}
 
   ~ContactElement() = default;
 
   bool operator==(const ContactElement & other) const {
     return slave == other.slave and master == other.master;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   inline UInt getNbNodes() const {
     auto nb_master_nodes = Mesh::getNbNodesPerElement(master.type);
     return nb_master_nodes + 1;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 public:
   /// slave node
   SlaveType slave;
 
   /// master element/node
   MasterType master;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_CONTACT_ELEMENT_HH__ */