diff --git a/package.cmake b/package.cmake
index cb01bd839..40f8f8034 100644
--- a/package.cmake
+++ b/package.cmake
@@ -1,40 +1,40 @@
 #===============================================================================
 # @file   package.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 #
 # @brief  package description for parallel cohesive elements
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 #===============================================================================
 
 package_declare(parallel_cohesive_element
   DESCRIPTION "Use parallel cohesive_element package of Akantu"
   DEPENDS cohesive_element parallel)
 
 package_declare_sources(parallel_cohesive_element
   cohesive_element_inserter_parallel.cc
   cohesive_element_inserter_inline_impl.cc
   solid_mechanics_model_cohesive_parallel.hh
   solid_mechanics_model_cohesive_parallel.cc
-  solid_mechanics_model_cohesive_inline_impl.cc
+  solid_mechanics_model_cohesive_parallel_inline_impl.cc
   facet_synchronizer.cc
   facet_synchronizer.hh
   facet_synchronizer_inline_impl.cc
   facet_stress_synchronizer.cc
   facet_stress_synchronizer.hh
   )
 
 set(AKANTU_PARALLEL_COHESIVE_ELEMENT_TESTS
   test_cohesive_parallel_intrinsic
   test_cohesive_parallel_extrinsic
   test_cohesive_parallel_extrinsic_IG_TG
   test_cohesive_ghost_element_insertion
   test_facet_synchronizer
   test_cohesive_parallel_buildfragments
   )
diff --git a/src/solid_mechanics_model_cohesive_inline_impl.cc b/src/solid_mechanics_model_cohesive_parallel_inline_impl.cc
similarity index 99%
rename from src/solid_mechanics_model_cohesive_inline_impl.cc
rename to src/solid_mechanics_model_cohesive_parallel_inline_impl.cc
index c700357d6..8e38b6fa8 100644
--- a/src/solid_mechanics_model_cohesive_inline_impl.cc
+++ b/src/solid_mechanics_model_cohesive_parallel_inline_impl.cc
@@ -1,332 +1,336 @@
 /**
- * @file   solid_mechanics_model_cohesive_inline_impl.cc
+ * @file   solid_mechanics_model_cohesive_parallel_inline_impl.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  *
  * @brief  Solid mechanics model inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
+__BEGIN_AKANTU__
+
 /* -------------------------------------------------------------------------- */
 inline UInt SolidMechanicsModelCohesive::getNbQuadsForFacetCheck(const Array<Element> & elements) const {
   UInt nb_quads = 0;
   UInt nb_quad_per_facet = 0;
 
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
 
   Array<Element>::const_iterator<Element> it  = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
 
     if(el.type != current_element_type || el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type   = el.ghost_type;
 
       nb_quad_per_facet = this->getFEEngine("FacetsFEEngine").getNbQuadraturePoints(el.type,
 									  el.ghost_type);
     }
 
     nb_quads += nb_quad_per_facet;
   }
 
   return nb_quads;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt SolidMechanicsModelCohesive::getNbNodesPerElementList(const Array<Element> & elements) const {
   UInt nb_nodes_per_element = 0;
   UInt nb_nodes = 0;
   ElementType current_element_type = _not_defined;
 
   Array<Element>::const_iterator<Element> el_it = elements.begin();
   Array<Element>::const_iterator<Element> el_end = elements.end();
 
   for (; el_it != el_end; ++el_it) {
     const Element & el = *el_it;
 
     if(el.type != current_element_type) {
       current_element_type = el.type;
       nb_nodes_per_element = Mesh::getNbNodesPerElement(current_element_type);
     }
 
     nb_nodes += nb_nodes_per_element;
   }
 
   return nb_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt SolidMechanicsModelCohesive::getNbDataForElements(const Array<Element> & elements,
 							      SynchronizationTag tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
 
   if (elements.getSize() == 0) return size;
 
   /// regular element case
   if (elements(0).kind == _ek_regular) {
 
     switch(tag) {
     case _gst_smmc_facets: {
       size += elements.getSize() * sizeof(bool);
       break;
     }
     case _gst_smmc_facets_conn: {
       UInt nb_nodes = getNbNodesPerElementList(elements);
       size += nb_nodes * sizeof(UInt);
       break;
     }
     case _gst_smmc_facets_stress: {
       UInt nb_quads = getNbQuadsForFacetCheck(elements);
       size += nb_quads * spatial_dimension * spatial_dimension * sizeof(Real);
       break;
     }
     default: {
       size += SolidMechanicsModel::getNbDataForElements(elements, tag);
     }
     }
   }
   /// cohesive element case
   else if (elements(0).kind == _ek_cohesive) {
 
     switch(tag) {
     case _gst_material_id: {
       size += elements.getSize() * 2 * sizeof(UInt);
       break;
     }
     case _gst_smm_boundary: {
       UInt nb_nodes_per_element = 0;
 
       Array<Element>::const_iterator<Element> it  = elements.begin();
       Array<Element>::const_iterator<Element> end = elements.end();
       for (; it != end; ++it) {
 	const Element & el = *it;
 	nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
       }
 
       // force, displacement, boundary
       size += nb_nodes_per_element * spatial_dimension * (2 * sizeof(Real) + sizeof(bool));
       break;
     }
     default: { }
     }
 
     if(tag != _gst_material_id && tag != _gst_smmc_facets) {
       Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
       this->splitElementByMaterial(elements, elements_per_mat);
 
       for (UInt i = 0; i < materials.size(); ++i) {
 	size += materials[i]->getNbDataForElements(elements_per_mat[i], tag);
       }
       delete [] elements_per_mat;
     }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SolidMechanicsModelCohesive::packElementData(CommunicationBuffer & buffer,
 							 const Array<Element> & elements,
 							 SynchronizationTag tag) const {
   AKANTU_DEBUG_IN();
 
   if (elements.getSize() == 0) return;
 
   if (elements(0).kind == _ek_regular) {
 
     switch(tag) {
 
     case _gst_smmc_facets: {
       packElementalDataHelper(inserter->getInsertionFacetsByElement(),
 			      buffer, elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       packElementalDataHelper(*global_connectivity, buffer, elements,
 			      false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       packFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     default: {
       SolidMechanicsModel::packElementData(buffer, elements, tag);
     }
     }
   }
   else if (elements(0).kind == _ek_cohesive) {
 
     switch(tag) {
 
     case _gst_material_id: {
       packElementalDataHelper(element_index_by_material, buffer,
 			      elements, false, getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       packNodalDataHelper(*force, buffer, elements, mesh);
       packNodalDataHelper(*velocity, buffer, elements, mesh);
       packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: { }
     }
 
     if(tag != _gst_material_id && tag != _gst_smmc_facets) {
       Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
       splitElementByMaterial(elements, elements_per_mat);
 
       for (UInt i = 0; i < materials.size(); ++i) {
 	materials[i]->packElementData(buffer, elements_per_mat[i], tag);
       }
 
       delete [] elements_per_mat;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SolidMechanicsModelCohesive::unpackElementData(CommunicationBuffer & buffer,
 							   const Array<Element> & elements,
 							   SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   if (elements.getSize() == 0) return;
 
   if (elements(0).kind == _ek_regular) {
 
     switch(tag) {
     case _gst_smmc_facets: {
       unpackElementalDataHelper(inserter->getInsertionFacetsByElement(),
 				buffer, elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       unpackElementalDataHelper(*global_connectivity, buffer, elements,
 				false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       unpackFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     default: {
       SolidMechanicsModel::unpackElementData(buffer, elements, tag);
     }
     }
   }
   else if (elements(0).kind == _ek_cohesive) {
 
     switch(tag) {
     case _gst_material_id: {
       unpackElementalDataHelper(element_index_by_material, buffer,
 				elements, false, getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       unpackNodalDataHelper(*force, buffer, elements, mesh);
       unpackNodalDataHelper(*velocity, buffer, elements, mesh);
       unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: { }
     }
 
     if(tag != _gst_material_id && tag != _gst_smmc_facets) {
       Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
       splitElementByMaterial(elements, elements_per_mat);
 
       for (UInt i = 0; i < materials.size(); ++i) {
 	materials[i]->unpackElementData(buffer, elements_per_mat[i], tag);
       }
 
       delete [] elements_per_mat;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 inline void SolidMechanicsModelCohesive::packFacetStressDataHelper(const ElementTypeMapArray<T> & data_to_pack,
 								   CommunicationBuffer & buffer,
 								   const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, true>(const_cast<ElementTypeMapArray<T> &>(data_to_pack),
 					   buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 inline void SolidMechanicsModelCohesive::unpackFacetStressDataHelper(ElementTypeMapArray<T> & data_to_unpack,
 								     CommunicationBuffer & buffer,
 								     const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, false>(data_to_unpack, buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template<typename T, bool pack_helper>
 inline void SolidMechanicsModelCohesive::packUnpackFacetStressDataHelper(ElementTypeMapArray<T> & data_to_pack,
 									 CommunicationBuffer & buffer,
 									 const Array<Element> & element) const {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   UInt nb_quad_per_elem = 0;
   UInt sp2 = spatial_dimension * spatial_dimension;
   UInt nb_component = sp2 * 2;
   bool element_rank = 0;
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   Array<T> * vect = NULL;
   Array<std::vector<Element> > * element_to_facet = NULL;
 
   Array<Element>::const_iterator<Element> it  = element.begin();
   Array<Element>::const_iterator<Element> end = element.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     if(el.type != current_element_type || el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type   = el.ghost_type;
       vect = &data_to_pack(el.type, el.ghost_type);
 
       element_to_facet =
 	&( mesh_facets.getElementToSubelement(el.type, el.ghost_type) );
 
       nb_quad_per_elem = this->getFEEngine("FacetsFEEngine").getNbQuadraturePoints(el.type,
 									 el.ghost_type);
     }
 
     if (pack_helper)
       element_rank = (*element_to_facet)(el.element)[0].ghost_type != _not_ghost;
     else
       element_rank = (*element_to_facet)(el.element)[0].ghost_type == _not_ghost;
 
     for (UInt q = 0; q < nb_quad_per_elem; ++q) {
       Vector<T> data(vect->storage()
 		     + (el.element * nb_quad_per_elem + q) * nb_component
 		     + element_rank * sp2,
 		     sp2);
 
       if(pack_helper)
 	buffer << data;
       else
 	buffer >> data;
     }
   }
 }
+
+__END_AKANTU__