diff --git a/blockMesher/src/main_blockmesher.cpp b/blockMesher/src/main_blockmesher.cpp
index d907ce5f9..026f7a682 100644
--- a/blockMesher/src/main_blockmesher.cpp
+++ b/blockMesher/src/main_blockmesher.cpp
@@ -1,15 +1,15 @@
 /*----------------------------------------------------------------------------*/
+#include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
+#include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/ig/Mesh.h>
 #include <gmds/ig/MeshDoctor.h>
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKReader.h>
 #include <gmds/io/VTKWriter.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
-#include <gmds/cad/GeomCurve.h>
-#include <gmds/cad/GeomSurface.h>
 #include <gmds/smoothy/AngleBasedQuadSmoother.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 /*----------------------------------------------------------------------------*/
 #include <iostream>
 #include <gmds/igalgo/BoundaryOperator.h>
@@ -449,15 +449,18 @@ int main(int argc, char* argv[])
 // PERFORM THE BLOCK SMOOTHING NOW
 //==================================================================
     std::cout<<"> Start block smoothing"<<std::endl;
-    smoothy::LaplacianSmoother smoother(&linker);
+    smoothy::LaplacianSmoother3C smoother(&blocking, &linker);
     if(!smoother.isValid())
     {
         std::cout<<"INVALID MODEL"<<std::endl;
         exit(1);
     }
     std::cout<<"  - start  smoothing ("<<nb_curve_smooth_iterations<<" iterations)"<<std::endl;
-    smoother.smoothCurves(nb_curve_smooth_iterations);
-    smoother.smoothSurfaces(nb_surface_smooth_iterations);
+	 smoother.setNodesAll();
+	 smoother.setNbIterations(nb_curve_smooth_iterations);
+    smoother.smoothCurves();
+	 smoother.setNbIterations(nb_surface_smooth_iterations);
+	 smoother.smoothSurfaces();
    // std::cout<<"  - start volume smoothing ("<<nb_volume_smooth_iterations<<" iterations)"<<std::endl;
    // smoother.smoothVolumes(nb_volume_smooth_iterations);
 
@@ -516,15 +519,17 @@ int main(int argc, char* argv[])
         if(info.second.dim==2)
             linker_final.linkFaceToSurface(f.id(),info.second.id);
     }
-    smoothy::LaplacianSmoother smoother_final(&linker_final);
+    smoothy::LaplacianSmoother3C smoother_final(bm.mesh(),&linker_final);
     if(!smoother_final.isValid())
     {
         std::cout<<"INVALID MODEL"<<std::endl;
         exit(1);
     }
     std::cout<<"  - start smoothing ("<<nb_curve_smooth_iterations<<" iterations)"<<std::endl;
-    smoother_final.smoothCurves(nb_curve_smooth_iterations);
-    smoother_final.smoothSurfaces(nb_surface_smooth_iterations);
+    smoother_final.setNbIterations(nb_curve_smooth_iterations);
+	 smoother_final.smoothCurves();
+	 smoother_final.setNbIterations(nb_surface_smooth_iterations);
+    smoother_final.smoothSurfaces();
     std::cout<<"> Start final mesh writing"<<std::endl;
     IGMeshIOService ioService_mesh(bm.mesh());
     VTKWriter vtkWriter_mesh(&ioService_mesh);
diff --git a/docs/doxygen/annotated.html b/docs/doxygen/annotated.html
index 85c6cdfdb..4d2c2dd0a 100644
--- a/docs/doxygen/annotated.html
+++ b/docs/doxygen/annotated.html
@@ -237,7 +237,7 @@
 <tr id="row_2_6_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span id="arr_2_6_" class="arrow" onclick="toggleFolder('2_6_')">&#9658;</span><span class="icona"><span class="icon">N</span></span><b>smoothy</b></td><td class="desc"></td></tr>
 <tr id="row_2_6_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html" target="_self">AbstractSmoother</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides attributes and methods that are shared by smoothing algorithms as child classes. It is abstract and so cannot be instanciated </td></tr>
 <tr id="row_2_6_1_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_angle_based_quad_smoother.html" target="_self">AngleBasedQuadSmoother</a></td><td class="desc"></td></tr>
-<tr id="row_2_6_2_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" target="_self">LaplacianSmoother</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually </td></tr>
+<tr id="row_2_6_2_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" target="_self">LaplacianSmoother3C</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually </td></tr>
 <tr id="row_2_7_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1_abstract_data.html" target="_self">AbstractData</a></td><td class="desc">Any data that we provide to a service must extend this abstract class </td></tr>
 <tr id="row_2_8_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1_abstract_service.html" target="_self">AbstractService</a></td><td class="desc">Defines the minimal interface of each service implemented in GMDS </td></tr>
 <tr id="row_2_9_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1_array2_d.html" target="_self">Array2D</a></td><td class="desc">Class implementing a 2D array made of T type objects </td></tr>
diff --git a/docs/doxygen/classes.html b/docs/doxygen/classes.html
index 884fe03a8..e0c06b163 100644
--- a/docs/doxygen/classes.html
+++ b/docs/doxygen/classes.html
@@ -334,7 +334,7 @@
 </tr>
 <tr><td valign="top"><a class="el" href="classgmds_1_1_cell_group.html">CellGroup</a> (<a class="el" href="namespacegmds.html">gmds</a>)&#160;&#160;&#160;</td>
 <td valign="top"><a class="el" href="classgmds_1_1_field_solver_strategy_itf.html">FieldSolverStrategyItf</a> (<a class="el" href="namespacegmds.html">gmds</a>)&#160;&#160;&#160;</td>
-<td valign="top"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother</a> (gmds::smoothy)&#160;&#160;&#160;</td>
+<td valign="top"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother3C</a> (gmds::smoothy)&#160;&#160;&#160;</td>
 <td valign="top"><a class="el" href="classgmds_1_1math_1_1_plane.html">Plane</a> (gmds::math)&#160;&#160;&#160;</td>
 <td valign="top"><a class="el" href="struct_s_point_data.html">SPointData</a>&#160;&#160;&#160;</td>
 </tr>
diff --git a/docs/doxygen/classgmds_1_1smoothy_1_1_abstract_smoother.html b/docs/doxygen/classgmds_1_1smoothy_1_1_abstract_smoother.html
index db7f814de..91acc9bbf 100644
--- a/docs/doxygen/classgmds_1_1smoothy_1_1_abstract_smoother.html
+++ b/docs/doxygen/classgmds_1_1smoothy_1_1_abstract_smoother.html
@@ -87,7 +87,7 @@
   <img src="classgmds_1_1smoothy_1_1_abstract_smoother.png" usemap="#gmds::smoothy::AbstractSmoother_map" alt=""/>
   <map id="gmds::smoothy::AbstractSmoother_map" name="gmds::smoothy::AbstractSmoother_map">
 <area href="classgmds_1_1smoothy_1_1_angle_based_quad_smoother.html" alt="gmds::smoothy::AngleBasedQuadSmoother" shape="rect" coords="0,56,251,80"/>
-<area href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" title="This class provides a straightforward implementation of a Laplacian smoother for meshes classifiend o..." alt="gmds::smoothy::LaplacianSmoother" shape="rect" coords="261,56,512,80"/>
+<area href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" title="This class provides a straightforward implementation of a Laplacian smoother for meshes classifiend o..." alt="gmds::smoothy::LaplacianSmoother3C" shape="rect" coords="261,56,512,80"/>
   </map>
 </div></div>
 <table class="memberdecls">
diff --git a/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother-members.html b/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother-members.html
index da57bc1e3..8a80afad0 100644
--- a/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother-members.html
+++ b/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother-members.html
@@ -62,29 +62,29 @@
 
 <div id="nav-path" class="navpath">
   <ul>
-<li class="navelem"><a class="el" href="namespacegmds.html">gmds</a></li><li class="navelem"><b>smoothy</b></li><li class="navelem"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother</a></li>  </ul>
+<li class="navelem"><a class="el" href="namespacegmds.html">gmds</a></li><li class="navelem"><b>smoothy</b></li><li class="navelem"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother3C</a></li>  </ul>
 </div>
 </div><!-- top -->
 <div class="header">
   <div class="headertitle">
-<div class="title">gmds::smoothy::LaplacianSmoother Member List</div>  </div>
+<div class="title">gmds::smoothy::LaplacianSmoother3C Member List</div>  </div>
 </div><!--header-->
 <div class="contents">
 
-<p>This is the complete list of members for <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a>, including all inherited members.</p>
+<p>This is the complete list of members for <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a>, including all inherited members.</p>
 <table class="directory">
   <tr class="even"><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a21a88a68c317e14a020c9f9fc4372f62">AbstractSmoother</a>(cad::GeomMeshLinker *ALinker)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a96277624266200de671d01255252d9b9">init</a>()</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a43eac155fc29e078267dcc1436a05055">isValid</a>() const</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">virtual</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>LaplacianSmoother</b>(cad::GeomMeshLinker *ALinker) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a></td><td class="entry"></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>LaplacianSmoother3C</b>(cad::GeomMeshLinker *ALinker) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a></td><td class="entry"></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#ac3c42e789b5814f9e22e2a5090332305">m_c2n</a></td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#acf9021bab0ce42ff92eac418f5a79d8e">m_linker</a></td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a0a1b605c97dc94bef91396dfdd6deef6">m_n2n</a></td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a36df8386cf4ded44a27b097d36be5c9d">m_s2n</a></td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html#a248d6a8a0ceb10cc937cd09e3ff654d7">m_v2n</a></td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html">gmds::smoothy::AbstractSmoother</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>smoothCurves</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a></td><td class="entry"></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>smoothSurfaces</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a></td><td class="entry"></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>smoothVolumes</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother</a></td><td class="entry"></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>smoothCurves</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a></td><td class="entry"></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>smoothSurfaces</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a></td><td class="entry"></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>smoothVolumes</b>(const int ANbIterations=1) (defined in <a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a>)</td><td class="entry"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">gmds::smoothy::LaplacianSmoother3C</a></td><td class="entry"></td></tr>
 </table></div><!-- contents -->
 <!-- start footer part -->
 <hr class="footer"/><address class="footer"><small>
diff --git a/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother.html b/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother.html
index ab19656be..b3f77d742 100644
--- a/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother.html
+++ b/docs/doxygen/classgmds_1_1smoothy_1_1_laplacian_smoother.html
@@ -5,7 +5,7 @@
 <meta http-equiv="X-UA-Compatible" content="IE=9"/>
 <meta name="generator" content="Doxygen 1.8.17"/>
 <meta name="viewport" content="width=device-width, initial-scale=1"/>
-<title>gmds: gmds::smoothy::LaplacianSmoother Class Reference</title>
+<title>gmds: gmds::smoothy::LaplacianSmoother3C Class Reference</title>
 <link href="tabs.css" rel="stylesheet" type="text/css"/>
 <script type="text/javascript" src="jquery.js"></script>
 <script type="text/javascript" src="dynsections.js"></script>
@@ -62,7 +62,7 @@
 
 <div id="nav-path" class="navpath">
   <ul>
-<li class="navelem"><a class="el" href="namespacegmds.html">gmds</a></li><li class="navelem"><b>smoothy</b></li><li class="navelem"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother</a></li>  </ul>
+<li class="navelem"><a class="el" href="namespacegmds.html">gmds</a></li><li class="navelem"><b>smoothy</b></li><li class="navelem"><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html">LaplacianSmoother3C</a></li>  </ul>
 </div>
 </div><!-- top -->
 <div class="header">
@@ -70,16 +70,16 @@
 <a href="#pub-methods">Public Member Functions</a> &#124;
 <a href="classgmds_1_1smoothy_1_1_laplacian_smoother-members.html">List of all members</a>  </div>
   <div class="headertitle">
-<div class="title">gmds::smoothy::LaplacianSmoother Class Reference</div>  </div>
+<div class="title">gmds::smoothy::LaplacianSmoother3C Class Reference</div>  </div>
 </div><!--header-->
 <div class="contents">
 
 <p><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually.  
  <a href="classgmds_1_1smoothy_1_1_laplacian_smoother.html#details">More...</a></p>
 
-<p><code>#include &lt;LaplacianSmoother.h&gt;</code></p>
+<p><code>#include &lt;LaplacianSmoother3C.h&gt;</code></p>
 <div class="dynheader">
-Inheritance diagram for gmds::smoothy::LaplacianSmoother:</div>
+Inheritance diagram for gmds::smoothy::LaplacianSmoother3C:</div>
 <div class="dyncontent">
  <div class="center">
   <img src="classgmds_1_1smoothy_1_1_laplacian_smoother.png" usemap="#gmds::smoothy::LaplacianSmoother_map" alt=""/>
@@ -91,7 +91,7 @@
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
 Public Member Functions</h2></td></tr>
 <tr class="memitem:a205815df1bf525404fa9824edfe631fc"><td class="memItemLeft" align="right" valign="top"><a id="a205815df1bf525404fa9824edfe631fc"></a>
-&#160;</td><td class="memItemRight" valign="bottom"><b>LaplacianSmoother</b> (<a class="el" href="classgmds_1_1cad_1_1_geom_mesh_linker.html">cad::GeomMeshLinker</a> *ALinker)</td></tr>
+&#160;</td><td class="memItemRight" valign="bottom"><b>LaplacianSmoother3C</b> (<a class="el" href="classgmds_1_1cad_1_1_geom_mesh_linker.html">cad::GeomMeshLinker</a> *ALinker)</td></tr>
 <tr class="separator:a205815df1bf525404fa9824edfe631fc"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a0d8375ff9d8cfb12679b3d54cef369b4"><td class="memItemLeft" align="right" valign="top"><a id="a0d8375ff9d8cfb12679b3d54cef369b4"></a>
 void&#160;</td><td class="memItemRight" valign="bottom"><b>smoothCurves</b> (const int ANbIterations=1)</td></tr>
@@ -132,8 +132,8 @@
 <a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
 <div class="textblock"><p><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually. </p>
 </div><hr/>The documentation for this class was generated from the following files:<ul>
-<li>/home/runner/work/gmds/gmds/smoothy/inc/gmds/smoothy/LaplacianSmoother.h</li>
-<li>/home/runner/work/gmds/gmds/smoothy/src/LaplacianSmoother.cpp</li>
+<li>/home/runner/work/gmds/gmds/smoothy/inc/gmds/smoothy/LaplacianSmoother3C.h</li>
+<li>/home/runner/work/gmds/gmds/smoothy/src/LaplacianSmoother3C.cpp</li>
 </ul>
 </div><!-- contents -->
 <!-- start footer part -->
diff --git a/docs/doxygen/hierarchy.html b/docs/doxygen/hierarchy.html
index 74b461828..686faf360 100644
--- a/docs/doxygen/hierarchy.html
+++ b/docs/doxygen/hierarchy.html
@@ -77,7 +77,7 @@
 <tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1_abstract_service.html" target="_self">gmds::AbstractService</a></td><td class="desc">Defines the minimal interface of each service implemented in GMDS </td></tr>
 <tr id="row_3_"><td class="entry"><span style="width:0px;display:inline-block;">&#160;</span><span id="arr_3_" class="arrow" onclick="toggleFolder('3_')">&#9658;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_abstract_smoother.html" target="_self">gmds::smoothy::AbstractSmoother</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides attributes and methods that are shared by smoothing algorithms as child classes. It is abstract and so cannot be instanciated </td></tr>
 <tr id="row_3_0_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_angle_based_quad_smoother.html" target="_self">gmds::smoothy::AngleBasedQuadSmoother</a></td><td class="desc"></td></tr>
-<tr id="row_3_1_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" target="_self">gmds::smoothy::LaplacianSmoother</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually </td></tr>
+<tr id="row_3_1_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classgmds_1_1smoothy_1_1_laplacian_smoother.html" target="_self">gmds::smoothy::LaplacianSmoother3C</a></td><td class="desc"><a class="el" href="class_this.html">This</a> class provides a straightforward implementation of a Laplacian smoother for meshes classifiend on geometric models. Curves, surfaces and volumes are smoothed individually </td></tr>
 <tr id="row_4_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structadd_data_policy.html" target="_self">addDataPolicy&lt; TBasicType, TCellType, TDataType &gt;</a></td><td class="desc"></td></tr>
 <tr id="row_5_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="struct_add_node.html" target="_self">AddNode</a></td><td class="desc"></td></tr>
 <tr id="row_6_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structgmds_1_1_face_container_1_1_adj_update.html" target="_self">gmds::FaceContainer::AdjUpdate&lt; N &gt;</a></td><td class="desc"></td></tr>
diff --git a/docs/mkdocs/user-guide/smoothy.md b/docs/mkdocs/user-guide/smoothy.md
index e0cc812bf..4d28f1dfc 100644
--- a/docs/mkdocs/user-guide/smoothy.md
+++ b/docs/mkdocs/user-guide/smoothy.md
@@ -4,6 +4,27 @@ The aim of this module is to gather some smoothing algorithms. Mesh smoothing al
 1. Those that are aware of the geometric classification. They are the less academic ones, but those used in practice. Most of the time they provide functions to smooth nodes on curves, surfaces and inside the volumes.
 2. The other ones that smooth all the nodes excepted a bunch of ones that are locked to their positions. They derive from academic papers that deal with such low constraints.
 
+## How to use a smoothing algorithm? 
+Like other meshing algorithms in **gmds**, smoothing algorithms provided an `isValid` method to check if the mesh we work
+on is adapted to the algorithm and a `smooth` method to perform the algorithm. As an example, let us consider the simple 2D 
+laplacian smoother without geometric classification (see the function `grid_2D_smooth_UC` in the test file [LaplacianSmootherTestSuite.h](../../../smoothy/tst/LaplacianSmootherTestSuite.h)). To call this 
+smoothing algorithm, we have a next series of instruction to write:
+```c++
+smoothy::LaplacianSmoother2UC smoother(&m);
+ASSERT_TRUE(smoother.isValid());
+smoother.setNbIterations(1);
+...
+smoother.setNodes(to_move);
+...
+smoother.smooth();
+```
+First, we initialize the *smoother* object as an instance of `LaplacianSmoother2UC`. It works on mesh `m`. The `2UC` 
+postfix means that the algorithm is 2D (`2`) and doesn't consider the classification (`UC`stands for *unclassified*).
+We check if the mesh `m` is valid for the algorithm with `smoother.isValid()`and then we indicate the number of iterations of the algorithm and the nodes to smooth. The `setNodes` method takes as parameters
+a vector of node ids.
+
+For an algorithm that use the geometric classification, we also need to provide the linker object as usual. See 
+for instance the test method `tet_in_cube` in the file [LaplacianSmootherTestSuite.h](../../../smoothy/tst/LaplacianSmootherTestSuite.h).
 ## Elliptic smoothing
 The elliptic smoother provides an implementation of the ACM TOG paper **Foldover-free maps in 50 lines of code** (https://dl.acm.org/doi/abs/10.1145/3450626.3459847).
 This algoriths allows to smooth a 2D mesh with some nodes that are locked. Example of usages are given in the unit tests.
\ No newline at end of file
diff --git a/dualBlocking/src/DualBlockingSession.cpp b/dualBlocking/src/DualBlockingSession.cpp
index 68e350913..b8732277c 100644
--- a/dualBlocking/src/DualBlockingSession.cpp
+++ b/dualBlocking/src/DualBlockingSession.cpp
@@ -2,16 +2,15 @@
 // Created by calderans on 06/03/19.
 //
 
-#include <gmds/dualBlocking/DualBlockingSession.h>
 #include <Predicates_psm.h>
+#include <ctime>
+#include <gmds/cad/GeomSurface.h>
+#include <gmds/dualBlocking/DualBlockingSession.h>
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKWriter.h>
-#include <gmds/cad/GeomSurface.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
 #include <gmds/math/Line.h>
-#include <ctime>
 #include <gmds/math/Orientation.h>
-
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 
 using namespace db;
 using namespace gmds;
diff --git a/graph/src/main.cpp b/graph/src/main.cpp
index 98cb0f7d7..b0c1a9589 100644
--- a/graph/src/main.cpp
+++ b/graph/src/main.cpp
@@ -11,7 +11,7 @@
 
 #include "gmds/graph/MinCut.h"
 
-#include <gmds/smoothy/LaplacianSmoother.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 
 using namespace gmds;
 using namespace graph;
diff --git a/medusa/inc/medusa/model/MedusaBackEnd.h b/medusa/inc/medusa/model/MedusaBackEnd.h
index 71b702793..239018731 100644
--- a/medusa/inc/medusa/model/MedusaBackEnd.h
+++ b/medusa/inc/medusa/model/MedusaBackEnd.h
@@ -9,10 +9,10 @@
 #include <medusa/model/MedusaGrid.h>
 #include <gmds/dualBlocking/DualBlockingSession.h>
 /*----------------------------------------------------------------------------*/
-#include <gmds/igalgo/BoundaryOperator.h>
-#include <gmds/graph/TopologyGraph.h>
-#include <gmds/frame3d/Params.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
+#	include <gmds/frame3d/Params.h>
+#	include <gmds/graph/TopologyGraph.h>
+#	include <gmds/igalgo/BoundaryOperator.h>
+#	include <gmds/smoothy/LaplacianSmoother3C.h>
 /*----------------------------------------------------------------------------*/
 
 namespace medusa{
diff --git a/rlBlocking/inc/gmds/rlBlocking/LinkerBlockingGeom.h b/rlBlocking/inc/gmds/rlBlocking/LinkerBlockingGeom.h
index 37e4523d4..c01a13b90 100644
--- a/rlBlocking/inc/gmds/rlBlocking/LinkerBlockingGeom.h
+++ b/rlBlocking/inc/gmds/rlBlocking/LinkerBlockingGeom.h
@@ -10,13 +10,12 @@
 #include <gmds/ig/Node.h>
 
 #include <gmds/blockMesher/BlockMesher.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/igalgo/BoundaryOperator.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
-
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKWriter.h>
diff --git a/rlBlocking/inc/gmds/rlBlocking/ValidBlocking.h b/rlBlocking/inc/gmds/rlBlocking/ValidBlocking.h
index 68adb3fc0..1e98a4a66 100644
--- a/rlBlocking/inc/gmds/rlBlocking/ValidBlocking.h
+++ b/rlBlocking/inc/gmds/rlBlocking/ValidBlocking.h
@@ -6,13 +6,12 @@
 #include <gmds/ig/Node.h>
 
 #include <gmds/blockMesher/BlockMesher.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/igalgo/BoundaryOperator.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
-
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKWriter.h>
diff --git a/rlBlocking/src/main_rlBlocking.cpp b/rlBlocking/src/main_rlBlocking.cpp
index 789c7546a..215da27f3 100644
--- a/rlBlocking/src/main_rlBlocking.cpp
+++ b/rlBlocking/src/main_rlBlocking.cpp
@@ -15,15 +15,14 @@
 #include <gmds/igalgo/GridBuilder.h>
 
 #include <gmds/blockMesher/BlockMesher.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
 #include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/igalgo/BoundaryOperator.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
 #include <gmds/rlBlocking/LinkerBlockingGeom.h>
 #include <gmds/rlBlocking/ValidBlocking.h>
-
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKWriter.h>
diff --git a/sheet/tst/SheetPillowTestSuite.h b/sheet/tst/SheetPillowTestSuite.h
index f0bd6eab3..ff366411b 100644
--- a/sheet/tst/SheetPillowTestSuite.h
+++ b/sheet/tst/SheetPillowTestSuite.h
@@ -1,15 +1,15 @@
 /*----------------------------------------------------------------------------*/
-#include <gtest/gtest.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/ig/Mesh.h>
 #include <gmds/ig/MeshDoctor.h>
-#include <gmds/io/VTKWriter.h>
-#include <gmds/sheet/Pillow3D.h>
 #include <gmds/igalgo/GridBuilder.h>
-#include <iostream>
 #include <gmds/io/IGMeshIOService.h>
+#include <gmds/io/VTKWriter.h>
 #include <gmds/sheet/Pillow2D.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
+#include <gmds/sheet/Pillow3D.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
+#include <gtest/gtest.h>
+#include <iostream>
 
 using namespace gmds;
 /*----------------------------------------------------------------------------*/
@@ -315,10 +315,11 @@ TEST(PillowOpClass, test_pillow3D_with_geom)
 
     manager.initAndLinkFrom3DMesh(&m_vol,&linker);
 
-    smoothy::LaplacianSmoother smoother(&linker);
-    smoother.smoothCurves(10);
-    smoother.smoothSurfaces(10);
-    smoother.smoothVolumes(10);
+    smoothy::LaplacianSmoother3C smoother(&m_vol, &linker);
+	 smoother.setNbIterations(10);
+    smoother.smoothCurves();
+    smoother.smoothSurfaces();
+    smoother.smoothVolumes();
 
     std::string vtk_file2 = ("hexa_pillow_out.vtk");
     IGMeshIOService ioService(&m_vol);
diff --git a/smoothy/CMakeLists.txt b/smoothy/CMakeLists.txt
index 8b157c820..79110bf38 100644
--- a/smoothy/CMakeLists.txt
+++ b/smoothy/CMakeLists.txt
@@ -9,18 +9,22 @@ set(GMDS_INC
         ${CMAKE_BINARY_DIR}/exports/${GMDS_LIB}_export.h
         inc/gmds/smoothy/AbstractSmoother.h
         inc/gmds/smoothy/AngleBasedQuadSmoother.h
-        inc/gmds/smoothy/LaplacianSmoother.h
+        inc/gmds/smoothy/LaplacianSmoother3C.h
+        inc/gmds/smoothy/LaplacianSmoother2UC.h
         inc/gmds/smoothy/HLBFGSWrapper.h
         inc/gmds/smoothy/EllipticSmoothing.h
         inc/gmds/smoothy/EllipticSmoother2D.h
+        inc/gmds/smoothy/SmoothingClassificationService.h
         )
 set(GMDS_SRC
         src/AbstractSmoother.cpp
         src/AngleBasedQuadSmoother.cpp
-        src/LaplacianSmoother.cpp
+        src/LaplacianSmoother3C.cpp
+        src/LaplacianSmoother2UC.cpp
         src/HLBFGSWrapper.cpp
         src/EllipticSmoothing.cpp
         src/EllipticSmoother2D.cpp
+        src/SmoothingClassificationService.cpp
         )
 #==============================================================================
 # HLBFGS include link (old fashion include)
diff --git a/smoothy/inc/gmds/smoothy/AbstractSmoother.h b/smoothy/inc/gmds/smoothy/AbstractSmoother.h
index 52d23e734..b7fea6ac1 100644
--- a/smoothy/inc/gmds/smoothy/AbstractSmoother.h
+++ b/smoothy/inc/gmds/smoothy/AbstractSmoother.h
@@ -1,56 +1,68 @@
 /*----------------------------------------------------------------------------*/
 // GMDS File Headers
 /*----------------------------------------------------------------------------*/
-#include <gmds/utils/CommonTypes.h>
-#include <gmds/cad/GeomMeshLinker.h>
 #include "GMDSSmoothy_export.h"
+#include <gmds/ig/Mesh.h>
+#include <gmds/utils/CommonTypes.h>
 /*----------------------------------------------------------------------------*/
 #ifndef GMDS_ABSTRACT_SMOOTHER_H
-#define GMDS_ABSTRACT_SMOOTHER_H
+#	define GMDS_ABSTRACT_SMOOTHER_H
 /*----------------------------------------------------------------------------*/
-namespace gmds{
+namespace gmds {
 /*----------------------------------------------------------------------------*/
-    namespace smoothy{
+namespace smoothy {
 /*----------------------------------------------------------------------------*/
 /** \class AbstractSmoother
- *  \brief This class provides attributes and methods that are shared by
+ *  \brief This class provides attributes and methods that are shared by all
  *         smoothing algorithms as child classes. It is abstract and so cannot
  *         be instanciated.
  */
 /*----------------------------------------------------------------------------*/
-        class GMDSSmoothy_API AbstractSmoother {
-        public:
-            /**@brief validation of the linker
-             * @return true if the linker is valid, i.e. the underlying mesh
-             *         has the right connection. False otherwise
-             */
-            virtual bool isValid() const;
-        protected:
-            /**@brief constructor
-             * @param ALinker the linker that has the knowledge and connection
-             *                between geometry and mesh
-             */
-            AbstractSmoother(cad::GeomMeshLinker* ALinker);
+class GMDSSmoothy_API AbstractSmoother
+{
+ public:
+	/**@brief constructor
+	 * @param ALinker the linker that has the knowledge and connection
+	 *                between geometry and mesh
+	 */
+	AbstractSmoother(Mesh *AMesh);
 
-            /**@brief initialize all the required technical attributes$
-             */
-            void init();
+	/**@brief validation of the mesh model
+	 * @return true if the model fits the algorithms requirement. False otherwise
+	 */
+	virtual bool isValid() const = 0;
+	/** Executes the smoothing algorithm
+	 * @return 1 if it succeeds, 0 if it fails. Other values could be returned by
+	 * specific implementations.
+	 */
+	virtual int smooth() = 0;
+	/**@brief specify the nodes to smooth
+	 * @param ANodeIds the list of node ids to smooth
+	 */
+	void setNodes(std::vector<TCellID> &ANodeIds);
+	/**@brief to smooth the whole mesh. In this case, the algorithm could be written on
+	 * the full mesh, but each algorithm can decide what to do with constrained nodes on the
+	 * boundary for instance.
+	 */
+	void setNodesAll();
+	/**@brief Set the number of smoothing iterations
+	 * @param ANbIterations the expected number of iterations
+	 */
+	void setNbIterations(const int ANbIterations);
+	;
 
-            /** linker*/
-            cad::GeomMeshLinker* m_linker;
-            /** for each curve id, we store the mesh node ids*/
-            std::map<int, std::vector<TCellID> > m_c2n;
-            /** for each surface id, we store the mesh node ids*/
-            std::map<int, std::vector<TCellID> > m_s2n;
-            /** for each volume id, we store the mesh node ids*/
-            std::map<int, std::vector<TCellID> > m_v2n;
-            /** local n2n connection build for the purposes of smoothing*/
-            std::map<TCellID, std::vector<TCellID> > m_n2n;
-        };
-/*----------------------------------------------------------------------------*/
-    } // end namespace cad
-/*----------------------------------------------------------------------------*/
-} // end namespace gmds
-/*----------------------------------------------------------------------------*/
-#endif //GMDS_ABSTRACT_SMOOTHER_H
+ protected:
+	/** the mesh we work on*/
+	Mesh *m_mesh;
+	/** the number of smoothing iterations*/
+	int m_nb_iterations;
+	/** the nodes we wants to smooth */
+	std::vector<TCellID> m_nodes;
+};
+/*----------------------------------------------------------------------------*/
+}     // namespace smoothy
+/*----------------------------------------------------------------------------*/
+}     // end namespace gmds
+/*----------------------------------------------------------------------------*/
+#endif     // GMDS_ABSTRACT_SMOOTHER_H
 /*----------------------------------------------------------------------------*/
diff --git a/smoothy/inc/gmds/smoothy/AngleBasedQuadSmoother.h b/smoothy/inc/gmds/smoothy/AngleBasedQuadSmoother.h
index 409d5f932..54576daa0 100644
--- a/smoothy/inc/gmds/smoothy/AngleBasedQuadSmoother.h
+++ b/smoothy/inc/gmds/smoothy/AngleBasedQuadSmoother.h
@@ -1,42 +1,48 @@
 /*----------------------------------------------------------------------------*/
 // GMDS File Headers
 /*----------------------------------------------------------------------------*/
-#include <gmds/smoothy/AbstractSmoother.h>
 #include "GMDSSmoothy_export.h"
+#include <gmds/smoothy/AbstractSmoother.h>
+#include <gmds/smoothy/SmoothingClassificationService.h>
 /*----------------------------------------------------------------------------*/
 #ifndef GMDS_ANGLE_BASED_QUAD_SMOOTHER_H
-#define GMDS_ANGLE_BASED_QUAD_SMOOTHER_H
+#	define GMDS_ANGLE_BASED_QUAD_SMOOTHER_H
 /*----------------------------------------------------------------------------*/
-namespace gmds{
+namespace gmds {
 /*----------------------------------------------------------------------------*/
-    namespace smoothy{
+namespace smoothy {
 /*----------------------------------------------------------------------------*/
 /** \class LaplacianSmoother
- *  \brief This class provides a straightforward implementation of a Laplacian
- *         smoother for meshes classifiend on geometric models. Curves, surfaces
- *         and volumes are smoothed individually.
+ *  \brief This class provides an angle-based smoother fo smoother
+ *  for 2D quad  meshes classified on geometric models.
  */
 /*----------------------------------------------------------------------------*/
-        class GMDSSmoothy_API AngleBasedQuadSmoother: public AbstractSmoother{
-        public:
-            AngleBasedQuadSmoother(cad::GeomMeshLinker* ALinker);
-            void smooth(const int ANbIterations=1);
-
+class GMDSSmoothy_API AngleBasedQuadSmoother : public AbstractSmoother, SmoothingClassificationService
+{
+ public:
+	AngleBasedQuadSmoother(Mesh* AMesh, cad::GeomMeshLinker *ALinker);
 
-            /**@brief validation of input
-             * @return check the linker (cf AbstractSmoother class) and check
-             *         that we have only quad faces in the mesh.
-             */
-            virtual bool isValid() const;
+	int smooth() override;
+	/**@brief validation of input
+	 * @return check the linker (cf AbstractSmoother class) and check
+	 *         that we have only quad faces in the mesh.
+	 */
+	bool isValid() const override;
 
-        private:
-            void smoothCurves();
-            void smoothSurfaces();
-        };
-/*----------------------------------------------------------------------------*/
-    } // end namespace cad
-/*----------------------------------------------------------------------------*/
-} // end namespace gmds
-/*----------------------------------------------------------------------------*/
-#endif //GMDS_ANGLE_BASED_QUAD_SMOOTHER_H
+ private:
+	/**
+	 * Smooth curves only
+	 */
+	void smoothCurves();
+	/**
+	 * Smooth surfaces only
+	 */
+	void smoothSurfaces();
+};
+/*----------------------------------------------------------------------------*/
+}     // namespace smoothy
+/*----------------------------------------------------------------------------*/
+}     // end namespace gmds
+/*----------------------------------------------------------------------------*/
+#endif     // GMDS_ANGLE_BASED_QUAD_SMOOTHER_H
 /*----------------------------------------------------------------------------*/
diff --git a/smoothy/inc/gmds/smoothy/LaplacianSmoother2UC.h b/smoothy/inc/gmds/smoothy/LaplacianSmoother2UC.h
new file mode 100644
index 000000000..576536ed5
--- /dev/null
+++ b/smoothy/inc/gmds/smoothy/LaplacianSmoother2UC.h
@@ -0,0 +1,48 @@
+/*----------------------------------------------------------------------------*/
+// GMDS File Headers
+/*----------------------------------------------------------------------------*/
+#include "GMDSSmoothy_export.h"
+#include <gmds/cad/GeomMeshLinker.h>
+#include <gmds/cadfac/FACManager.h>
+#include <gmds/smoothy/AbstractSmoother.h>
+#include <gmds/utils/CommonTypes.h>
+#include <gmds/utils/Exception.h>
+/*----------------------------------------------------------------------------*/
+#ifndef GMDS_LAPLACIANSMOOTHER_2UC_H
+#	define GMDS_LAPLACIANSMOOTHER_2UC_H
+/*----------------------------------------------------------------------------*/
+namespace gmds {
+/*----------------------------------------------------------------------------*/
+namespace smoothy {
+/*----------------------------------------------------------------------------*/
+/** \class LaplacianSmoother
+ *  \brief This class provides a straightforward implementation of a Laplacian
+ *         smoother for unclassified 2D meshes.
+ */
+/*----------------------------------------------------------------------------*/
+class GMDSSmoothy_API LaplacianSmoother2UC : public AbstractSmoother
+{
+ public:
+	/**@brief constructor
+	 * @param AMesh the mesh we work on
+	 */
+	LaplacianSmoother2UC(Mesh *AMesh);
+	/** @brief check if the mesh is valid for performing the algorithm.
+	 * More specifically the mesh must not have regions and the relation N2F
+	 * must be available.
+	 *
+	 * @return true if the mesh is valid, false otherwise.
+	 */
+	bool isValid() const override;
+	/** @brief perform the smoothing algorithm
+	 * @return 1 if the mesh is smoothed
+	 */
+	int smooth() override;
+};
+/*----------------------------------------------------------------------------*/
+}     // namespace smoothy
+/*----------------------------------------------------------------------------*/
+}     // end namespace gmds
+/*----------------------------------------------------------------------------*/
+#endif     // GMDS_LAPLACIANSMOOTHER_2UC_H
+/*----------------------------------------------------------------------------*/
diff --git a/smoothy/inc/gmds/smoothy/LaplacianSmoother.h b/smoothy/inc/gmds/smoothy/LaplacianSmoother3C.h
similarity index 70%
rename from smoothy/inc/gmds/smoothy/LaplacianSmoother.h
rename to smoothy/inc/gmds/smoothy/LaplacianSmoother3C.h
index 015d45a2f..c20990c23 100644
--- a/smoothy/inc/gmds/smoothy/LaplacianSmoother.h
+++ b/smoothy/inc/gmds/smoothy/LaplacianSmoother3C.h
@@ -1,19 +1,20 @@
 /*----------------------------------------------------------------------------*/
 // GMDS File Headers
 /*----------------------------------------------------------------------------*/
-#include <gmds/utils/Exception.h>
-#include <gmds/utils/CommonTypes.h>
+#include "GMDSSmoothy_export.h"
 #include <gmds/cad/GeomMeshLinker.h>
 #include <gmds/cadfac/FACManager.h>
 #include <gmds/smoothy/AbstractSmoother.h>
-#include "GMDSSmoothy_export.h"
+#include <gmds/smoothy/SmoothingClassificationService.h>
+#include <gmds/utils/CommonTypes.h>
+#include <gmds/utils/Exception.h>
 /*----------------------------------------------------------------------------*/
-#ifndef GMDS_LAPLACIANSMOOTHER_H
-#define GMDS_LAPLACIANSMOOTHER_H
+#ifndef GMDS_LAPLACIANSMOOTHER_3C_H
+#	define GMDS_LAPLACIANSMOOTHER_3C_H
 /*----------------------------------------------------------------------------*/
-namespace gmds{
+namespace gmds {
 /*----------------------------------------------------------------------------*/
-    namespace smoothy{
+namespace smoothy {
 /*----------------------------------------------------------------------------*/
 /** \class LaplacianSmoother
  *  \brief This class provides a straightforward implementation of a Laplacian
@@ -21,18 +22,20 @@ namespace gmds{
  *         and volumes are smoothed individually.
  */
 /*----------------------------------------------------------------------------*/
-        class GMDSSmoothy_API LaplacianSmoother: public AbstractSmoother{
-        public:
-            LaplacianSmoother(cad::GeomMeshLinker* ALinker);
-            void smoothCurves(const int ANbIterations=1);
-            void smoothSurfaces(const int ANbIterations=1);
-            void smoothVolumes(const int ANbIterations=1);
-
-        };
+class GMDSSmoothy_API LaplacianSmoother3C : public AbstractSmoother, SmoothingClassificationService
+{
+ public:
+	LaplacianSmoother3C(Mesh *AMesh, cad::GeomMeshLinker *ALinker);
+	bool isValid() const override;
+	int smooth() override;
+	void smoothCurves();
+	void smoothSurfaces();
+	void smoothVolumes();
+};
 /*----------------------------------------------------------------------------*/
-    } // end namespace cad
+}     // namespace smoothy
 /*----------------------------------------------------------------------------*/
-} // end namespace gmds
+}     // end namespace gmds
 /*----------------------------------------------------------------------------*/
-#endif //GMDS_LAPLACIANSMOOTHER_H
+#endif     // GMDS_LAPLACIANSMOOTHER_3C_H
 /*----------------------------------------------------------------------------*/
diff --git a/smoothy/inc/gmds/smoothy/SmoothingClassificationService.h b/smoothy/inc/gmds/smoothy/SmoothingClassificationService.h
new file mode 100644
index 000000000..be9106cc5
--- /dev/null
+++ b/smoothy/inc/gmds/smoothy/SmoothingClassificationService.h
@@ -0,0 +1,57 @@
+/*----------------------------------------------------------------------------*/
+// GMDS File Headers
+/*----------------------------------------------------------------------------*/
+#include "GMDSSmoothy_export.h"
+#include <gmds/cad/GeomMeshLinker.h>
+#include <gmds/utils/CommonTypes.h>
+/*----------------------------------------------------------------------------*/
+#ifndef GMDS_SMOOTHING_CLASSIFICATION_SERVICE_H
+#	define GMDS_SMOOTHING_CLASSIFICATION_SERVICE_H
+/*----------------------------------------------------------------------------*/
+namespace gmds {
+/*----------------------------------------------------------------------------*/
+namespace smoothy {
+/*----------------------------------------------------------------------------*/
+/** \class SmoothingClassificationService
+ *  \brief This class provides attributes and methods that are shared by all
+ *         smoothing algorithms that smooth classified meshes, i.e. meshes that
+ *         are deeply linked to a geometric model.
+ */
+/*----------------------------------------------------------------------------*/
+class GMDSSmoothy_API SmoothingClassificationService
+{
+ public:
+	/**@brief constructor
+	 * @param ALinker the linker that has the knowledge and connection
+	 *                between geometry and mesh
+	 */
+	SmoothingClassificationService(cad::GeomMeshLinker *ALinker);
+
+	/**@brief validation of the mesh model
+	 * @return true if the model fits the algorithms requirement. False otherwise
+	 */
+	bool isValidForClassification() const;
+
+ protected:
+	/**@brief initialize all the required technical attributes$
+	 */
+	void init();
+
+	/** linker*/
+	cad::GeomMeshLinker *m_linker;
+	/** for each curve id, we store the mesh node ids*/
+	std::map<int, std::vector<TCellID>> m_c2n;
+	/** for each surface id, we store the mesh node ids*/
+	std::map<int, std::vector<TCellID>> m_s2n;
+	/** for each volume id, we store the mesh node ids*/
+	std::map<int, std::vector<TCellID>> m_v2n;
+	/** local n2n connection build for the purposes of smoothing*/
+	std::map<TCellID, std::vector<TCellID>> m_n2n;
+};
+/*----------------------------------------------------------------------------*/
+}     // namespace smoothy
+/*----------------------------------------------------------------------------*/
+}     // end namespace gmds
+/*----------------------------------------------------------------------------*/
+#endif     // GMDS_SMOOTHING_CLASSIFICATION_SERVICE_H
+/*----------------------------------------------------------------------------*/
diff --git a/smoothy/inc/gmds/smoothy/mat.h b/smoothy/inc/gmds/smoothy/mat.h
deleted file mode 100644
index e69de29bb..000000000
diff --git a/smoothy/inc/gmds/smoothy/vec.h b/smoothy/inc/gmds/smoothy/vec.h
deleted file mode 100644
index e69de29bb..000000000
diff --git a/smoothy/src/AbstractSmoother.cpp b/smoothy/src/AbstractSmoother.cpp
index c09cf8b72..cb0a8c163 100644
--- a/smoothy/src/AbstractSmoother.cpp
+++ b/smoothy/src/AbstractSmoother.cpp
@@ -5,107 +5,29 @@ using namespace gmds;
 using namespace gmds::smoothy;
 using namespace gmds::cad;
 /*----------------------------------------------------------------------------*/
-AbstractSmoother::AbstractSmoother(GeomMeshLinker* ALinker)
-:m_linker(ALinker)
+AbstractSmoother::AbstractSmoother(Mesh* AMesh)
+:m_mesh(AMesh),m_nb_iterations(0)
+{}
+/*----------------------------------------------------------------------------*/
+void
+AbstractSmoother::setNbIterations(const int ANbIterations)
 {
-    init();
+	if(ANbIterations<0)
+		throw GMDSException("Smoothing iteration number must be positive!");
+	m_nb_iterations = ANbIterations;
 }
 /*----------------------------------------------------------------------------*/
-bool AbstractSmoother::isValid() const
+void
+AbstractSmoother::setNodes(std::vector<TCellID> &ANodeIds)
 {
-    bool valid_input=true;
-    MeshModel model = m_linker->mesh()->getModel();
-    if (!model.has(R)   ||
-    !model.has(F)   ||
-    !model.has(E)   ||
-    !model.has(N)   ||
-    !model.has(R2N) ||
-    !model.has(F2N) ||
-    !model.has(E2N) ||
-    !model.has(N2E) ||
-    !model.has(N2F) )
-        valid_input= false;
-
-    if(!valid_input)
-        return false;
-
-
-    return true;
+	m_nodes = ANodeIds;
 }
 /*----------------------------------------------------------------------------*/
-void AbstractSmoother::init() {
-
-    //NO I NEED EDGE ON CURVE AND FACE ON SURFACE. OTHERWISE, I CANNOT DO SOMETHING
-    //GOOD FOR THIN AREA, WHICH WILL OCCUR VERY OFTEN IN FACT
-
-    Mesh *m = m_linker->mesh();
-    for (auto n_id:m->nodes()) {
-        auto geom_info = m_linker->getGeomInfo<Node>(n_id);
-        if (geom_info.first == GeomMeshLinker::LinkCurve) {
-            //Means on a curve
-            m_c2n[geom_info.second].push_back(n_id);
-        } else if (geom_info.first == GeomMeshLinker::LinkSurface) {
-            //Means on a surface
-            m_s2n[geom_info.second].push_back(n_id);
-        } else if (geom_info.first == GeomMeshLinker::NoLink ||
-        geom_info.first == GeomMeshLinker::LinkVolume) {
-            //Means in a volume
-            m_v2n[geom_info.second].push_back(n_id);
-        }
-
-    }
-
-    //Now we build the local N2N connection that is useful for the smoothing
-    for (auto n_id:m->nodes()) {
-        auto geom_dim = m_linker->getGeomDim<Node>(n_id);
-        auto geom_id = m_linker->getGeomId<Node>(n_id);
-
-        if (geom_dim == GeomMeshLinker::LinkCurve) {
-            //Means on a curve
-            std::vector<Edge> edges = m->get<Node>(n_id).get<Edge>();
-
-            for (auto e:edges) {
-                if (m_linker->getGeomDim(e) == GeomMeshLinker::LinkCurve &&
-                    m_linker->getGeomId(e) == geom_id) {
-                    //Edge e is linked to the same curve as n_id
-                    std::vector<TCellID> nids = e.getIDs<Node>();
-                    if (nids[0] == n_id) {
-                        m_n2n[n_id].push_back(nids[1]);
-                    } else {
-                        m_n2n[n_id].push_back(nids[0]);
-                    }
-                }
-            }
-        } else if (geom_dim == GeomMeshLinker::LinkSurface) {
-            //Means on a surface
-            std::vector<Face> faces = m->get<Node>(n_id).get<Face>();
-
-            for (auto f:faces) {
-                if (m_linker->getGeomDim(f) == GeomMeshLinker::LinkSurface &&
-                m_linker->getGeomId(f) == geom_id) {
-                    //Face f is linked to the same surface as n_id
-                    std::vector<TCellID> nids = f.getIDs<Node>();
-                    for (auto ni:nids) {
-                        if (ni != n_id) {
-                            m_n2n[n_id].push_back(ni);
-                        }
-                    }
-                }
-            }
-        } else if (geom_dim == GeomMeshLinker::NoLink ||
-        geom_dim == GeomMeshLinker::LinkVolume) {
-            //Means in a volume
-            std::vector<Region> regions = m->get<Node>(n_id).get<Region>();
-
-            for (auto r:regions) {
-                std::vector<TCellID> nids = r.getIDs<Node>();
-                for (auto ni:nids) {
-                    if (ni != n_id) {
-                        m_n2n[n_id].push_back(ni);
-                    }
-                }
-            }
-        }
-    }
+void
+AbstractSmoother::setNodesAll()
+{
+	m_nodes.reserve(m_mesh->getNbNodes());
+	for(auto n_id:m_mesh->nodes())
+		m_nodes.push_back(n_id);
 }
 /*----------------------------------------------------------------------------*/
diff --git a/smoothy/src/AngleBasedQuadSmoother.cpp b/smoothy/src/AngleBasedQuadSmoother.cpp
index ff442a3b5..d84361e5e 100644
--- a/smoothy/src/AngleBasedQuadSmoother.cpp
+++ b/smoothy/src/AngleBasedQuadSmoother.cpp
@@ -5,22 +5,27 @@ using namespace gmds;
 using namespace gmds::smoothy;
 using namespace gmds::cad;
 /*----------------------------------------------------------------------------*/
-AngleBasedQuadSmoother::AngleBasedQuadSmoother(GeomMeshLinker* ALinker)
-:AbstractSmoother(ALinker)
+AngleBasedQuadSmoother::AngleBasedQuadSmoother(gmds::Mesh *AMesh, cad::GeomMeshLinker *ALinker)
+:AbstractSmoother(AMesh), SmoothingClassificationService(ALinker)
 {}
 /*----------------------------------------------------------------------------*/
-void AngleBasedQuadSmoother::smooth(const int ANbIterations) {
+int AngleBasedQuadSmoother::smooth() {
     //we iteratively smooth curves and surfaces
-    for (auto i = 0; i < ANbIterations; i++) {
+    for (auto i = 0; i < m_nb_iterations; i++) {
         smoothSurfaces();
         smoothCurves();
     }
+	 return 1;
 }
 /*----------------------------------------------------------------------------*/
 bool AngleBasedQuadSmoother::isValid() const {
-    bool model_valid = AbstractSmoother::isValid();
+    bool model_valid = SmoothingClassificationService::isValidForClassification();
     if(!model_valid)
         return false;
+
+	 if(m_linker->mesh()!=m_mesh)
+		  return false;
+
     for(auto f_id:m_linker->mesh()->faces()){
         if(m_linker->mesh()->get<Face>(f_id).type()!=GMDS_QUAD)
             return false;
diff --git a/smoothy/src/LaplacianSmoother2UC.cpp b/smoothy/src/LaplacianSmoother2UC.cpp
new file mode 100644
index 000000000..e05df4ef1
--- /dev/null
+++ b/smoothy/src/LaplacianSmoother2UC.cpp
@@ -0,0 +1,53 @@
+/*----------------------------------------------------------------------------*/
+#include <gmds/smoothy/LaplacianSmoother2UC.h>
+/*----------------------------------------------------------------------------*/
+using namespace gmds;
+using namespace gmds::smoothy;
+using namespace gmds::cad;
+/*----------------------------------------------------------------------------*/
+LaplacianSmoother2UC::LaplacianSmoother2UC(gmds::Mesh *AMesh) : AbstractSmoother(AMesh) {}
+/*----------------------------------------------------------------------------*/
+bool LaplacianSmoother2UC::isValid() const
+{
+	MeshModel model = m_mesh->getModel();
+	if (model.has(R)) return false;
+
+	if (!model.has(N2F) && !model.has(F2N)) return false;
+
+	return true;
+}
+/*----------------------------------------------------------------------------*/
+int LaplacianSmoother2UC::smooth()
+{
+	// First we build the N2N connectivity for the nodes to be smoothed
+	std::map<TCellID, std::set<TCellID>> n2n;
+	for (auto nid : m_nodes) {
+		Node ni = m_mesh->get<Node>(nid);
+		std::vector<Face> ni_faces = ni.get<Face>();
+		for (auto f : ni_faces) {
+			TCellID id1, id2;
+			f.getAdjacentNodes(nid, id1, id2);
+			n2n[nid].insert(id1);
+			n2n[nid].insert(id2);
+		}
+	}
+
+	for (auto i = 0; i < m_nb_iterations; i++) {
+
+		// We smooth each node in a naive way
+		for (auto nid : m_nodes) {
+			Node ni = m_mesh->get<Node>(nid);
+			std::set<TCellID> adj_n = n2n[nid];
+			math::Point pi(0, 0, 0);
+			for (auto adj_id : adj_n) {
+				math::Point pj = m_mesh->get<Node>(adj_id).point();
+				pi = pi + pj;
+			}
+			pi = pi * (1.0 / adj_n.size());
+			ni.setPoint(pi);
+		}
+	}
+
+	return 1;
+}
+/*----------------------------------------------------------------------------*/
diff --git a/smoothy/src/LaplacianSmoother.cpp b/smoothy/src/LaplacianSmoother3C.cpp
similarity index 79%
rename from smoothy/src/LaplacianSmoother.cpp
rename to smoothy/src/LaplacianSmoother3C.cpp
index 8145cf71f..84645b75c 100644
--- a/smoothy/src/LaplacianSmoother.cpp
+++ b/smoothy/src/LaplacianSmoother3C.cpp
@@ -1,20 +1,39 @@
 /*----------------------------------------------------------------------------*/
-#include <gmds/smoothy/LaplacianSmoother.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 /*----------------------------------------------------------------------------*/
 using namespace gmds;
 using namespace gmds::smoothy;
 using namespace gmds::cad;
 /*----------------------------------------------------------------------------*/
-LaplacianSmoother::LaplacianSmoother(GeomMeshLinker* ALinker)
-: AbstractSmoother(ALinker) {}
+LaplacianSmoother3C::LaplacianSmoother3C(gmds::Mesh *AMesh, cad::GeomMeshLinker *ALinker)
+  : AbstractSmoother(AMesh), SmoothingClassificationService(ALinker) {}
 /*----------------------------------------------------------------------------*/
-void LaplacianSmoother::smoothCurves(const int ANbIterations) {
+bool
+LaplacianSmoother3C::isValid() const
+{
+	if(m_mesh!=m_linker->mesh())
+		return false;
+
+	return isValidForClassification();
+}
+/*----------------------------------------------------------------------------*/
+int
+LaplacianSmoother3C::smooth()
+{
+	smoothCurves();
+	smoothSurfaces();
+	smoothVolumes();
+	return 1;
+}
+/*----------------------------------------------------------------------------*/
+void
+LaplacianSmoother3C::smoothCurves() {
 
     std::vector<GeomCurve*> curves;
     m_linker->geometry()->getCurves(curves);
     Mesh* m = m_linker->mesh();
 
-    for(auto i=0;i<ANbIterations;i++) {
+    for(auto i=0;i<m_nb_iterations;i++) {
         for (auto c:curves) {
 
             //We get all the nodes of the curve
@@ -44,13 +63,14 @@ void LaplacianSmoother::smoothCurves(const int ANbIterations) {
 
 }
 /*----------------------------------------------------------------------------*/
-void LaplacianSmoother::smoothSurfaces(const int ANbIterations) {
+void
+LaplacianSmoother3C::smoothSurfaces() {
 
 
     std::vector<GeomSurface*> surfs;
     m_linker->geometry()->getSurfaces(surfs);
     Mesh* m = m_linker->mesh();
-    for(auto i=0;i<ANbIterations;i++) {
+    for(auto i=0;i<m_nb_iterations;i++) {
         for (auto s:surfs) {
             //We get all the nodes of the surface
             auto ids_of_nodes_on_surf = m_s2n[s->id()];
@@ -75,11 +95,12 @@ void LaplacianSmoother::smoothSurfaces(const int ANbIterations) {
     }
 }
 /*----------------------------------------------------------------------------*/
-void LaplacianSmoother::smoothVolumes(const int ANbIterations) {
+void
+LaplacianSmoother3C::smoothVolumes() {
 
     Mesh* m = m_linker->mesh();
 
-    for(auto i=0;i<ANbIterations;i++) {
+    for(auto i=0;i<m_nb_iterations;i++) {
         for (auto vol_info:m_v2n) {
 
             //We get all the nodes of the first volume (or void)
diff --git a/smoothy/src/SmoothingClassificationService.cpp b/smoothy/src/SmoothingClassificationService.cpp
new file mode 100644
index 000000000..b8e708013
--- /dev/null
+++ b/smoothy/src/SmoothingClassificationService.cpp
@@ -0,0 +1,111 @@
+/*----------------------------------------------------------------------------*/
+#include <gmds/smoothy/SmoothingClassificationService.h>
+/*----------------------------------------------------------------------------*/
+using namespace gmds;
+using namespace gmds::smoothy;
+using namespace gmds::cad;
+/*----------------------------------------------------------------------------*/
+SmoothingClassificationService::SmoothingClassificationService(GeomMeshLinker* ALinker)
+:m_linker(ALinker)
+{
+    init();
+}
+/*----------------------------------------------------------------------------*/
+bool SmoothingClassificationService::isValidForClassification() const
+{
+    bool valid_input=true;
+    MeshModel model = m_linker->mesh()->getModel();
+    if (!model.has(R)   ||
+    !model.has(F)   ||
+    !model.has(E)   ||
+    !model.has(N)   ||
+    !model.has(R2N) ||
+    !model.has(F2N) ||
+    !model.has(E2N) ||
+    !model.has(N2E) ||
+    !model.has(N2F) )
+        valid_input= false;
+
+    if(!valid_input)
+        return false;
+
+
+    return true;
+}
+/*----------------------------------------------------------------------------*/
+void SmoothingClassificationService::init() {
+
+    //NO I NEED EDGE ON CURVE AND FACE ON SURFACE. OTHERWISE, I CANNOT DO SOMETHING
+    //GOOD FOR THIN AREA, WHICH WILL OCCUR VERY OFTEN IN FACT
+
+    Mesh *m = m_linker->mesh();
+    for (auto n_id:m->nodes()) {
+        auto geom_info = m_linker->getGeomInfo<Node>(n_id);
+        if (geom_info.first == GeomMeshLinker::LinkCurve) {
+            //Means on a curve
+            m_c2n[geom_info.second].push_back(n_id);
+        } else if (geom_info.first == GeomMeshLinker::LinkSurface) {
+            //Means on a surface
+            m_s2n[geom_info.second].push_back(n_id);
+        } else if (geom_info.first == GeomMeshLinker::NoLink ||
+        geom_info.first == GeomMeshLinker::LinkVolume) {
+            //Means in a volume
+            m_v2n[geom_info.second].push_back(n_id);
+        }
+
+    }
+
+    //Now we build the local N2N connection that is useful for the smoothing
+    for (auto n_id:m->nodes()) {
+        auto geom_dim = m_linker->getGeomDim<Node>(n_id);
+        auto geom_id = m_linker->getGeomId<Node>(n_id);
+
+        if (geom_dim == GeomMeshLinker::LinkCurve) {
+            //Means on a curve
+            std::vector<Edge> edges = m->get<Node>(n_id).get<Edge>();
+
+            for (auto e:edges) {
+                if (m_linker->getGeomDim(e) == GeomMeshLinker::LinkCurve &&
+                    m_linker->getGeomId(e) == geom_id) {
+                    //Edge e is linked to the same curve as n_id
+                    std::vector<TCellID> nids = e.getIDs<Node>();
+                    if (nids[0] == n_id) {
+                        m_n2n[n_id].push_back(nids[1]);
+                    } else {
+                        m_n2n[n_id].push_back(nids[0]);
+                    }
+                }
+            }
+        } else if (geom_dim == GeomMeshLinker::LinkSurface) {
+            //Means on a surface
+            std::vector<Face> faces = m->get<Node>(n_id).get<Face>();
+
+            for (auto f:faces) {
+                if (m_linker->getGeomDim(f) == GeomMeshLinker::LinkSurface &&
+                m_linker->getGeomId(f) == geom_id) {
+                    //Face f is linked to the same surface as n_id
+                    std::vector<TCellID> nids = f.getIDs<Node>();
+                    for (auto ni:nids) {
+                        if (ni != n_id) {
+                            m_n2n[n_id].push_back(ni);
+                        }
+                    }
+                }
+            }
+        } else if (geom_dim == GeomMeshLinker::NoLink ||
+        geom_dim == GeomMeshLinker::LinkVolume) {
+            //Means in a volume
+            std::vector<Region> regions = m->get<Node>(n_id).get<Region>();
+
+            for (auto r:regions) {
+                std::vector<TCellID> nids = r.getIDs<Node>();
+                for (auto ni:nids) {
+                    if (ni != n_id) {
+                        m_n2n[n_id].push_back(ni);
+                    }
+                }
+            }
+        }
+    }
+}
+/*----------------------------------------------------------------------------*/
diff --git a/smoothy/src/morph2d.cpp b/smoothy/src/morph2d.cpp
index 0e1a4b16d..b0981e666 100644
--- a/smoothy/src/morph2d.cpp
+++ b/smoothy/src/morph2d.cpp
@@ -1,15 +1,15 @@
 /*----------------------------------------------------------------------------*/
+#include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
+#include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/ig/Mesh.h>
 #include <gmds/ig/MeshDoctor.h>
+#include <gmds/igalgo/BoundaryOperator.h>
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKReader.h>
 #include <gmds/io/VTKWriter.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
-#include <gmds/cad/GeomCurve.h>
-#include <gmds/cad/GeomSurface.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
-#include <gmds/igalgo/BoundaryOperator.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 /*----------------------------------------------------------------------------*/
 #include "gmds/igalgo/BoundaryOperator2D.h"
 #include <gmds/smoothy/EllipticSmoother2D.h>
diff --git a/smoothy/src/smoothy.cpp b/smoothy/src/smoothy.cpp
index d756469b4..d1ed232ba 100644
--- a/smoothy/src/smoothy.cpp
+++ b/smoothy/src/smoothy.cpp
@@ -1,15 +1,15 @@
 /*----------------------------------------------------------------------------*/
+#include <gmds/cad/GeomCurve.h>
+#include <gmds/cad/GeomPoint.h>
+#include <gmds/cad/GeomSurface.h>
+#include <gmds/cadfac/FACManager.h>
 #include <gmds/ig/Mesh.h>
 #include <gmds/ig/MeshDoctor.h>
+#include <gmds/igalgo/BoundaryOperator.h>
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKReader.h>
 #include <gmds/io/VTKWriter.h>
-#include <gmds/cadfac/FACManager.h>
-#include <gmds/cad/GeomPoint.h>
-#include <gmds/cad/GeomCurve.h>
-#include <gmds/cad/GeomSurface.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
-#include <gmds/igalgo/BoundaryOperator.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
 /*----------------------------------------------------------------------------*/
 #include <iostream>
 
@@ -289,18 +289,19 @@ int main(int argc, char* argv[])
     // PERFORM THE MESH SMOOTHING NOW
     //==================================================================
     std::cout<<"> Start smoothing"<<std::endl;
-    smoothy::LaplacianSmoother smoother(&linker);
+    smoothy::LaplacianSmoother3C smoother(&m,&linker);
     if(!smoother.isValid())
     {
         std::cout<<"INVALID MODEL"<<std::endl;
         exit(1);
     }
+	 smoother.setNbIterations(nb_iterations);
     std::cout<<"  - start curve smoothing ("<<nb_iterations<<" iterations)"<<std::endl;
-    smoother.smoothCurves(nb_iterations);
+    smoother.smoothCurves();
     std::cout<<"  - start surface smoothing ("<<nb_iterations<<" iterations)"<<std::endl;
-    smoother.smoothSurfaces(nb_iterations);
+    smoother.smoothSurfaces();
     std::cout<<"  - start volume smoothing ("<<nb_iterations<<" iterations)"<<std::endl;
-    smoother.smoothVolumes(nb_iterations);
+    smoother.smoothVolumes();
 
     //==================================================================
     // COMPUTE FINAL QUALITY
diff --git a/smoothy/tst/AngleBasedQuadSmootherTestSuite.h b/smoothy/tst/AngleBasedQuadSmootherTestSuite.h
index 85950b464..c38d8f274 100644
--- a/smoothy/tst/AngleBasedQuadSmootherTestSuite.h
+++ b/smoothy/tst/AngleBasedQuadSmootherTestSuite.h
@@ -43,10 +43,11 @@ TEST(AngleBasedQuadSmootherTestSuite, s24_quad_smoother)
 
     manager.initAndLinkFrom3DMesh(&m_vol,&linker);
 
-    smoothy::AngleBasedQuadSmoother smoother(&linker);
+    smoothy::AngleBasedQuadSmoother smoother(&m_vol,&linker);
     ASSERT_TRUE(smoother.isValid());
-
-    smoother.smooth(100);
+	smoother.setNodesAll();
+	smoother.setNbIterations(100);
+    smoother.smooth();
 
 
     std::string vtk_file2 = dir+"/Notch/out.vtk";
diff --git a/smoothy/tst/LaplacianSmootherTestSuite.h b/smoothy/tst/LaplacianSmootherTestSuite.h
index 97171a83b..29d8ca921 100644
--- a/smoothy/tst/LaplacianSmootherTestSuite.h
+++ b/smoothy/tst/LaplacianSmootherTestSuite.h
@@ -4,379 +4,414 @@
 /*----------------------------------------------------------------------------*/
 #include <gtest/gtest.h>
 /*----------------------------------------------------------------------------*/
-#include <gmds/ig/Mesh.h>
-#include <gmds/cadfac/FACManager.h>
 #include <gmds/cad/GeomMeshLinker.h>
-#include <gmds/smoothy/LaplacianSmoother.h>
+#include <gmds/cadfac/FACManager.h>
+#include <gmds/ig/Mesh.h>
+#include <gmds/igalgo/BoundaryOperator.h>
+#include <gmds/igalgo/GridBuilder.h>
 #include <gmds/io/IGMeshIOService.h>
 #include <gmds/io/VTKReader.h>
 #include <gmds/io/VTKWriter.h>
-#include <gmds/igalgo/GridBuilder.h>
-#include <gmds/igalgo/BoundaryOperator.h>
+#include <gmds/smoothy/LaplacianSmoother3C.h>
+#include <gmds/smoothy/LaplacianSmoother2UC.h>
 #include <unit_test_config.h>
 /*----------------------------------------------------------------------------*/
 using namespace gmds;
 /*----------------------------------------------------------------------------*/
-TEST(GeomSmootherTestSuite, tet_in_cube)
+TEST(LaplacianSmootherTestSuite, tet_in_cube)
 {
-    // WE WRITE
-    Mesh m_vol(gmds::MeshModel(DIM3|R|F|E|N|
-                               R2N|R2F|R2E|
-                               F2N|F2R|F2E|
-                               E2F|E2N|N2E|N2R|N2F));
+	// WE WRITE
+	Mesh m_vol(gmds::MeshModel(DIM3 | R | F | E | N | R2N | R2F | R2E | F2N | F2R | F2E | E2F | E2N | N2E | N2R | N2F));
 
-    std::string dir(TEST_SAMPLES_DIR);
-    std::string vtk_file = dir+"/tet_in_box.vtk";
-    IGMeshIOService ioService(&m_vol);
+	std::string dir(TEST_SAMPLES_DIR);
+	std::string vtk_file = dir + "/tet_in_box.vtk";
+	IGMeshIOService ioService(&m_vol);
 
-    VTKReader vtkReader(&ioService);
-    vtkReader.setCellOptions(gmds::N|gmds::R);
-    vtkReader.read(vtk_file);
+	VTKReader vtkReader(&ioService);
+	vtkReader.setCellOptions(gmds::N | gmds::R);
+	vtkReader.read(vtk_file);
 
-    MeshDoctor doc(&m_vol);
-    doc.buildFacesAndR2F();
-    doc.buildEdgesAndX2E();
-    doc.updateUpwardConnectivity();
+	MeshDoctor doc(&m_vol);
+	doc.buildFacesAndR2F();
+	doc.buildEdgesAndX2E();
+	doc.updateUpwardConnectivity();
 
-    cad::FACManager manager;
-    cad::GeomMeshLinker linker;
+	cad::FACManager manager;
+	cad::GeomMeshLinker linker;
 
-    manager.initAndLinkFrom3DMesh(&m_vol,&linker);
+	manager.initAndLinkFrom3DMesh(&m_vol, &linker);
 
-    smoothy::LaplacianSmoother smoother(&linker);
+	smoothy::LaplacianSmoother3C smoother(&m_vol, &linker);
+	smoother.setNbIterations(100);
+	smoother.setNodesAll();
 
-    //We perturb mesh node locations to test the smoothing algorithm
-    for(auto n_id:m_vol.nodes()){
-        if(n_id==8){
-            m_vol.get<Node>(n_id).setPoint(math::Point(5,1,5));
-        }
-        else if(n_id==10){
-            m_vol.get<Node>(n_id).setPoint(math::Point(-5,1,5));
-        }
-        else if(n_id==20){
-            m_vol.get<Node>(n_id).setPoint(math::Point(-2,2,5));
-        }
-        else if (n_id==28){
-            m_vol.get<Node>(n_id).setPoint(math::Point(1,1,3));
-        }
-    }
+	// We perturb mesh node locations to test the smoothing algorithm
+	for (auto n_id : m_vol.nodes()) {
+		if (n_id == 8) {
+			m_vol.get<Node>(n_id).setPoint(math::Point(5, 1, 5));
+		}
+		else if (n_id == 10) {
+			m_vol.get<Node>(n_id).setPoint(math::Point(-5, 1, 5));
+		}
+		else if (n_id == 20) {
+			m_vol.get<Node>(n_id).setPoint(math::Point(-2, 2, 5));
+		}
+		else if (n_id == 28) {
+			m_vol.get<Node>(n_id).setPoint(math::Point(1, 1, 3));
+		}
+	}
 
+	std::string vtk_file2 = ("TOTO_moved.vtk");
 
-    std::string vtk_file2 = ("TOTO_moved.vtk");
+	VTKWriter vtkWriter(&ioService);
+	vtkWriter.setCellOptions(gmds::N | gmds::R);
+	vtkWriter.setDataOptions(gmds::N | gmds::R);
+	vtkWriter.write(vtk_file2);
 
-    VTKWriter vtkWriter(&ioService);
-    vtkWriter.setCellOptions(gmds::N|gmds::R);
-    vtkWriter.setDataOptions(gmds::N|gmds::R);
-    vtkWriter.write(vtk_file2);
+	smoother.smoothCurves();
 
-    smoother.smoothCurves(100);
+	std::string vtk_file3 = ("TOTO_smooth.vtk");
 
-    std::string vtk_file3 = ("TOTO_smooth.vtk");
+	vtkWriter.write(vtk_file3);
 
-    vtkWriter.write(vtk_file3);
+	ASSERT_NEAR(m_vol.get<Node>(8).point().Y(), 0, 0.01);
+	ASSERT_NEAR(m_vol.get<Node>(10).point().Y(), 0, 0.01);
 
-    ASSERT_NEAR(m_vol.get<Node>(8).point().Y(), 0, 0.01);
-    ASSERT_NEAR(m_vol.get<Node>(10).point().Y(), 0, 0.01);
+	smoother.setNbIterations(10);
+	smoother.smoothSurfaces();
 
-    smoother.smoothSurfaces();
-
-    ASSERT_NEAR(m_vol.get<Node>(20).point().X(), -1, 0.01);
-    ASSERT_NEAR(m_vol.get<Node>(20).point().Y(), 1, 0.01);
-
-    smoother.smoothVolumes();
-
-    ASSERT_NEAR(m_vol.get<Node>(28).point().X(), 2.08, 0.01);
-    ASSERT_NEAR(m_vol.get<Node>(28).point().Y(), 0.64, 0.01);
-    ASSERT_NEAR(m_vol.get<Node>(28).point().Z(), 1.97, 0.01);
+	ASSERT_NEAR(m_vol.get<Node>(20).point().X(), -1, 0.01);
+	ASSERT_NEAR(m_vol.get<Node>(20).point().Y(), 1, 0.01);
 
+	smoother.setNbIterations(1);
+	smoother.smoothVolumes();
 
+	ASSERT_NEAR(m_vol.get<Node>(28).point().X(), 2.08, 0.01);
+	ASSERT_NEAR(m_vol.get<Node>(28).point().Y(), 0.64, 0.01);
+	ASSERT_NEAR(m_vol.get<Node>(28).point().Z(), 1.97, 0.01);
 }
 
 /*----------------------------------------------------------------------------*/
-TEST(GeomSmootherTestSuite, test3)
+TEST(LaplacianSmootherTestSuite, test3)
 {
-    Mesh m_vol(gmds::MeshModel(DIM3|R|F|E|N|
-    R2N|R2F|R2E|
-    F2N|F2R|F2E|
-    E2F|E2N|N2E|N2R|N2F));
-    std::string dir(TEST_SAMPLES_DIR);
-    std::string vtk_file = dir+"/hexa.vtk";
-
-    IGMeshIOService ioService(&m_vol);
+	Mesh m_vol(gmds::MeshModel(DIM3 | R | F | E | N | R2N | R2F | R2E | F2N | F2R | F2E | E2F | E2N | N2E | N2R | N2F));
+	std::string dir(TEST_SAMPLES_DIR);
+	std::string vtk_file = dir + "/hexa.vtk";
 
-    VTKReader vtkReader(&ioService);
-    vtkReader.setCellOptions(gmds::N|gmds::R);
-    vtkReader.read(vtk_file);
+	IGMeshIOService ioService(&m_vol);
 
-    m_vol.deleteRegion(0);
-    m_vol.deleteRegion(1);
-    m_vol.deleteRegion(2);
-    m_vol.deleteRegion(3);
+	VTKReader vtkReader(&ioService);
+	vtkReader.setCellOptions(gmds::N | gmds::R);
+	vtkReader.read(vtk_file);
 
-    MeshDoctor doc(&m_vol);
-    doc.buildFacesAndR2F();
-    doc.buildEdgesAndX2E();
-    doc.updateUpwardConnectivity();
+	m_vol.deleteRegion(0);
+	m_vol.deleteRegion(1);
+	m_vol.deleteRegion(2);
+	m_vol.deleteRegion(3);
 
-    cad::FACManager manager;
-    cad::GeomMeshLinker linker;
+	MeshDoctor doc(&m_vol);
+	doc.buildFacesAndR2F();
+	doc.buildEdgesAndX2E();
+	doc.updateUpwardConnectivity();
 
-    manager.initAndLinkFrom3DMesh(&m_vol,&linker);
+	cad::FACManager manager;
+	cad::GeomMeshLinker linker;
 
-    smoothy::LaplacianSmoother smoother(&linker);
+	manager.initAndLinkFrom3DMesh(&m_vol, &linker);
 
+	smoothy::LaplacianSmoother3C smoother(&m_vol,&linker);
+smoother.setNbIterations(10);
+smoother.setNodesAll();
+	smoother.smoothCurves();
 
-    smoother.smoothCurves(10);
+	smoother.smoothSurfaces();
 
-    smoother.smoothSurfaces(10);
+	smoother.smoothVolumes();
 
-    smoother.smoothVolumes(10);
+	std::string vtk_file2 = ("test_samples/hexa_out.vtk");
 
-    std::string vtk_file2 = ("test_samples/hexa_out.vtk");
+	VTKWriter vtkWriter(&ioService);
+	vtkWriter.setCellOptions(gmds::N | gmds::R);
+	// vtkWriter.setDataOptions(gmds::N|gmds::R);
+	vtkWriter.write(vtk_file2);
+	ASSERT_TRUE(true);
+}
 
-    VTKWriter vtkWriter(&ioService);
-    vtkWriter.setCellOptions(gmds::N|gmds::R);
-    // vtkWriter.setDataOptions(gmds::N|gmds::R);
-    vtkWriter.write(vtk_file2);
-    ASSERT_TRUE(true);
+/*----------------------------------------------------------------------------*/
+TEST(LaplacianSmootherTestSuite, DISABLED_test_notch_refined)
+{
+	std::string dir(TEST_SAMPLES_DIR);
+	std::string file_geom = dir + "/Notch/notch_tet.vtk";
+	std::string file_mesh = dir + "/Notch/notch_hexa.vtk";
+
+	auto nb_iterations = 10;
+	//==================================================================
+	// GEOMETRY READING
+	//==================================================================
+	Mesh geometry(MeshModel(DIM3 | R | F | E | N | R2N | R2F | R2E | F2N | F2R | F2E | E2F | E2N | N2E | N2R | N2F));
+
+	IGMeshIOService ioService(&geometry);
+	VTKReader vtkReader(&ioService);
+	vtkReader.setCellOptions(N | R);
+	vtkReader.read(file_geom);
+	MeshDoctor doc(&geometry);
+	doc.buildFacesAndR2F();
+	doc.buildEdgesAndX2E();
+	doc.updateUpwardConnectivity();
+
+	cad::FACManager geom_manager;
+	geom_manager.initFrom3DMesh(&geometry);
+	//==================================================================
+	// MESH READING
+	//==================================================================
+	// the used model is specified according to the geom smoother requirements.
+	Mesh m(MeshModel(DIM3 | R | F | E | N | R2N | R2F | R2E | F2N | F2R | F2E | E2F | E2N | N2E | N2R | N2F));
+
+	IGMeshIOService ioService2(&m);
+	VTKReader vtkReader2(&ioService2);
+	vtkReader2.setCellOptions(N | R);
+	vtkReader2.read(file_mesh);
+	MeshDoctor doc2(&m);
+	doc2.buildFacesAndR2F();
+	doc2.buildEdgesAndX2E();
+	doc2.updateUpwardConnectivity();
+
+	//==================================================================
+	// MARK ALL THE BOUNDARY CELL OF THE INIT MESH
+	//==================================================================
+	// we get all the nodes that are on the mesh boundary
+	BoundaryOperator op(&m);
+	auto mark_node_NAN = m.newMark<Node>();
+	auto mark_node_on_pnt = m.newMark<Node>();
+	auto mark_node_on_crv = m.newMark<Node>();
+	auto mark_node_on_srf = m.newMark<Node>();
+	auto mark_edge_on_crv = m.newMark<Edge>();
+	auto mark_edge_on_srf = m.newMark<Edge>();
+	auto mark_face_on_srf = m.newMark<Face>();
+
+	op.markCellOnGeometry(mark_face_on_srf, mark_edge_on_srf, mark_node_on_srf, mark_edge_on_crv, mark_node_on_crv, mark_node_on_pnt, mark_node_NAN);
+
+	//==================================================================
+	// TRY TO CLASSIFY MESH CELLS
+	// The classification process is not straightforward as we have to
+	// consider that the mesh to classify is a "coarse" version of the
+	// geometry. For instance, if you try and project the middle point
+	// of an edge onto a curve, the distance between the initial point
+	// and the projected one will be probably not equal to zero. While,
+	// the same point will be lying on adjacent surface with a null
+	// distance. So the strategy is to
+	// 1. Classify faces on surfaces
+	// 2. Get edges that are shared by two faces classified onto 2
+	//    surfaces. Those edges must be classified on curves. It is
+	//    also the case of the edge endpoint
+	// 3. Do the same for nodes shared by at least 3 faces classified
+	//    onto 3 surfaces. Those nodes must be classified onto points.
+	//==================================================================
+
+	cad::GeomMeshLinker linker(&m, &geom_manager);
+	std::vector<cad::GeomSurface *> surfaces;
+	std::vector<cad::GeomCurve *> curves;
+	std::vector<cad::GeomPoint *> points;
+
+	geom_manager.getSurfaces(surfaces);
+	geom_manager.getCurves(curves);
+	geom_manager.getPoints(points);
+
+	//==================================================================
+	// First, we classify each face
+	for (auto f_id : m.faces()) {
+		Face f = m.get<Face>(f_id);
+		if (m.isMarked(f, mark_face_on_srf)) {
+			// we've got a boundary face
+			math::Point p = f.center();
+
+			double min_dist = 100000;
+			int min_entity_dim = -1;
+			int min_entity_id = -1;
+			for (auto s : surfaces) {
+				math::Point closest_pnt = p;
+				s->project(closest_pnt);
+				double dist = p.distance2(closest_pnt);
+				if (dist < min_dist) {
+					min_dist = dist;
+					min_entity_dim = 2;
+					min_entity_id = s->id();
+				}
+			}
+			if (min_entity_dim == 2) {
+				linker.linkFaceToSurface(f_id, min_entity_id);
+			}
+		}
+	}
+	//==================================================================
+	// Second, we classify each edge
+	for (auto e_id : m.edges()) {
+		Edge e = m.get<Edge>(e_id);
+		if (m.isMarked(e, mark_edge_on_crv) || m.isMarked(e, mark_edge_on_srf)) {
+			// we've got a boundary edge, now we get the 2 boundary faces
+			//  around e
+			std::vector<Node> e_nodes = e.get<Node>();
+			std::vector<TCellID> adj_face_id = e.getIDs<Face>();
+			std::vector<TCellID> adj_bnd_face_ids;
+			for (auto f_id : adj_face_id) {
+				if (m.isMarked<Face>(f_id, mark_face_on_srf)) {
+					adj_bnd_face_ids.push_back(f_id);
+				}
+			}
+			auto surf0_id = linker.getGeomId<Face>(adj_bnd_face_ids[0]);
+			auto surf1_id = linker.getGeomId<Face>(adj_bnd_face_ids[1]);
+
+			if (surf0_id == surf1_id) {
+				// edge embedded in the surface
+				linker.linkEdgeToSurface(e_id, surf1_id);
+			}
+			else {
+				// it must be an edge classified on curves
+				// we look for the closest curve now
+				math::Point p0 = e_nodes[0].point();
+				math::Point p1 = e_nodes[1].point();
+				math::Point p = 0.5 * (p0 + p1);
+
+				double min_dist = 100000;
+				int min_entity_dim = -1;
+				int min_entity_id = -1;
+				for (auto c : curves) {
+					math::Point closest_pnt = p;
+					c->project(closest_pnt);
+					double dist = p.distance2(closest_pnt);
+					if (dist < min_dist) {
+						min_dist = dist;
+						min_entity_dim = 1;
+						min_entity_id = c->id();
+					}
+				}
+				linker.linkEdgeToCurve(e_id, min_entity_id);
+			}
+		}
+	}
+	//==================================================================
+	// we classify each node
+	auto on_pnt = 0, on_curve = 0, on_surf = 0;
+	for (auto n_id : m.nodes()) {
+		Node n = m.get<Node>(n_id);
+		if (m.isMarked(n, mark_node_on_pnt) || m.isMarked(n, mark_node_on_crv) || m.isMarked(n, mark_node_on_srf)) {
+			// we've got a boundary node
+			math::Point node_loc = n.point();
+			double min_dist = 100000;
+			int min_entity_dim = -1;
+			int min_entity_id = -1;
+			for (auto p : points) {
+				math::Point closest_pnt = node_loc;
+				double dist = node_loc.distance(p->point());
+				if (dist < min_dist) {
+					min_dist = dist;
+					min_entity_dim = 0;
+					min_entity_id = p->id();
+				}
+			}
+			for (auto c : curves) {
+				math::Point closest_pnt = node_loc;
+				c->project(closest_pnt);
+				double dist = node_loc.distance(closest_pnt);
+				if (dist < min_dist) {
+					// WARNING: Take care of this trick that is not good at all but mandatory to be staying on the
+					//  curve and not on the surface
+					if (dist < 1e-4) dist = 0;
+					min_dist = dist;
+					min_entity_dim = 1;
+					min_entity_id = c->id();
+				}
+			}
+			for (auto s : surfaces) {
+				math::Point closest_pnt = node_loc;
+				s->project(closest_pnt);
+				double dist = node_loc.distance(closest_pnt);
+				if (dist < min_dist) {
+					min_dist = dist;
+					min_entity_dim = 2;
+					min_entity_id = s->id();
+				}
+			}
+
+			if (min_entity_dim == 0) {
+				on_pnt++;
+				linker.linkNodeToPoint(n_id, min_entity_id);
+			}
+			else if (min_entity_dim == 1) {
+				on_curve++;
+				linker.linkNodeToCurve(n_id, min_entity_id);
+			}
+			else if (min_entity_dim == 2) {
+				on_surf++;
+				linker.linkNodeToSurface(n_id, min_entity_id);
+			}
+			else {
+				throw GMDSException("Link error for classifying a node");
+			}
+		}
+	}
+	//==================================================================
+	// PERFORM THE MESH SMOOTHING NOW
+	//==================================================================
+	smoothy::LaplacianSmoother3C smoother(&m,&linker);
+	smoother.setNbIterations(nb_iterations);
+	smoother.setNodesAll();
+	smoother.smoothCurves();
+	smoother.smoothSurfaces();
+	smoother.smoothVolumes();
+
+	ASSERT_TRUE(true);
 }
 
 /*----------------------------------------------------------------------------*/
-TEST(GeomSmootherTestSuite, DISABLED_test_notch_refined)
+TEST(LaplacianSmootherTestSuite, grid_2D_smooth_UC)
 {
-    std::string dir(TEST_SAMPLES_DIR);
-    std::string file_geom = dir+"/Notch/notch_tet.vtk";
-    std::string file_mesh = dir+"/Notch/notch_hexa.vtk";
-
-    auto nb_iterations = 10;
-    //==================================================================
-    // GEOMETRY READING
-    //==================================================================
-    Mesh geometry(MeshModel(DIM3 | R | F | E | N |
-    R2N | R2F | R2E |
-    F2N | F2R | F2E |
-    E2F | E2N | N2E | N2R | N2F));
-
-    IGMeshIOService ioService(&geometry);
-    VTKReader vtkReader(&ioService);
-    vtkReader.setCellOptions(N| R);
-    vtkReader.read(file_geom);
-    MeshDoctor doc(&geometry);
-    doc.buildFacesAndR2F();
-    doc.buildEdgesAndX2E();
-    doc.updateUpwardConnectivity();
-
-    cad::FACManager geom_manager;
-    geom_manager.initFrom3DMesh(&geometry);
-    //==================================================================
-    // MESH READING
-    //==================================================================
-    //the used model is specified according to the geom smoother requirements.
-    Mesh m(MeshModel(DIM3 | R | F | E | N |
-    R2N | R2F | R2E | F2N | F2R | F2E | E2F | E2N | N2E | N2R | N2F));
-
-    IGMeshIOService ioService2(&m);
-    VTKReader vtkReader2(&ioService2);
-    vtkReader2.setCellOptions(N|R);
-    vtkReader2.read(file_mesh);
-    MeshDoctor doc2(&m);
-    doc2.buildFacesAndR2F();
-    doc2.buildEdgesAndX2E();
-    doc2.updateUpwardConnectivity();
-
-    //==================================================================
-    // MARK ALL THE BOUNDARY CELL OF THE INIT MESH
-    //==================================================================
-    //we get all the nodes that are on the mesh boundary
-    BoundaryOperator op(&m);
-    auto mark_node_NAN = m.newMark<Node>();
-    auto mark_node_on_pnt = m.newMark<Node>();
-    auto mark_node_on_crv = m.newMark<Node>();
-    auto mark_node_on_srf = m.newMark<Node>();
-    auto mark_edge_on_crv = m.newMark<Edge>();
-    auto mark_edge_on_srf = m.newMark<Edge>();
-    auto mark_face_on_srf = m.newMark<Face>();
-
-    op.markCellOnGeometry(mark_face_on_srf,
-                          mark_edge_on_srf,
-                          mark_node_on_srf,
-                          mark_edge_on_crv,
-                          mark_node_on_crv,
-                          mark_node_on_pnt,
-                          mark_node_NAN);
-
-
-    //==================================================================
-    // TRY TO CLASSIFY MESH CELLS
-    // The classification process is not straightforward as we have to
-    // consider that the mesh to classify is a "coarse" version of the
-    // geometry. For instance, if you try and project the middle point
-    // of an edge onto a curve, the distance between the initial point
-    // and the projected one will be probably not equal to zero. While,
-    // the same point will be lying on adjacent surface with a null
-    // distance. So the strategy is to
-    // 1. Classify faces on surfaces
-    // 2. Get edges that are shared by two faces classified onto 2
-    //    surfaces. Those edges must be classified on curves. It is
-    //    also the case of the edge endpoint
-    // 3. Do the same for nodes shared by at least 3 faces classified
-    //    onto 3 surfaces. Those nodes must be classified onto points.
-    //==================================================================
-
-    cad::GeomMeshLinker linker(&m, &geom_manager);
-    std::vector<cad::GeomSurface*> surfaces;
-    std::vector<cad::GeomCurve*> curves;
-    std::vector<cad::GeomPoint*> points;
-
-    geom_manager.getSurfaces(surfaces);
-    geom_manager.getCurves(curves);
-    geom_manager.getPoints(points);
-
-    //==================================================================
-    //First, we classify each face
-    for(auto f_id: m.faces()){
-        Face f= m.get<Face>(f_id);
-        if(m.isMarked(f, mark_face_on_srf) ){
-            //we've got a boundary face
-            math::Point p = f.center();
-
-            double min_dist = 100000;
-            int min_entity_dim=-1;
-            int min_entity_id = -1;
-            for(auto s:surfaces){
-                math::Point closest_pnt=p;
-                s->project(closest_pnt);
-                double dist = p.distance2(closest_pnt);
-                if(dist<min_dist){
-                    min_dist =dist;
-                    min_entity_dim=2;
-                    min_entity_id=s->id();
-                }
-            }
-            if (min_entity_dim==2){
-                linker.linkFaceToSurface(f_id,min_entity_id);
-            }
-        }
-    }
-    //==================================================================
-    //Second, we classify each edge
-    for(auto e_id: m.edges()){
-        Edge e= m.get<Edge>(e_id);
-        if(m.isMarked(e, mark_edge_on_crv) ||
-        m.isMarked(e, mark_edge_on_srf) ){
-            //we've got a boundary edge, now we get the 2 boundary faces
-            // around e
-            std::vector<Node> e_nodes = e.get<Node>();
-            std::vector<TCellID> adj_face_id = e.getIDs<Face>();
-            std::vector<TCellID> adj_bnd_face_ids;
-            for(auto f_id:adj_face_id){
-                if(m.isMarked<Face>(f_id,mark_face_on_srf)){
-                    adj_bnd_face_ids.push_back(f_id);
-                }
-            }
-            auto surf0_id = linker.getGeomId<Face>(adj_bnd_face_ids[0]);
-            auto surf1_id = linker.getGeomId<Face>(adj_bnd_face_ids[1]);
-
-            if(surf0_id==surf1_id){
-                //edge embedded in the surface
-                linker.linkEdgeToSurface(e_id,surf1_id);
-            }
-            else{
-                //it must be an edge classified on curves
-                //we look for the closest curve now
-                math::Point p0 = e_nodes[0].point();
-                math::Point p1 = e_nodes[1].point();
-                math::Point p = 0.5*(p0+p1);
-
-                double min_dist = 100000;
-                int min_entity_dim=-1;
-                int min_entity_id = -1;
-                for(auto c:curves){
-                    math::Point closest_pnt=p;
-                    c->project(closest_pnt);
-                    double dist = p.distance2(closest_pnt);
-                    if(dist<min_dist){
-                        min_dist =dist;
-                        min_entity_dim=1;
-                        min_entity_id=c->id();
-                    }
-                }
-                linker.linkEdgeToCurve(e_id,min_entity_id);
-            }
-        }
-    }
-    //==================================================================
-    //we classify each node
-    auto on_pnt=0, on_curve=0, on_surf=0;
-    for(auto n_id: m.nodes()){
-        Node n= m.get<Node>(n_id);
-        if(m.isMarked(n, mark_node_on_pnt) ||
-        m.isMarked(n, mark_node_on_crv) ||
-        m.isMarked(n, mark_node_on_srf) ){
-            //we've got a boundary node
-            math::Point node_loc = n.point();
-            double min_dist = 100000;
-            int min_entity_dim=-1;
-            int min_entity_id = -1;
-            for(auto p:points){
-                math::Point closest_pnt=node_loc;
-                double dist = node_loc.distance(p->point());
-                if(dist<min_dist){
-                    min_dist =dist;
-                    min_entity_dim=0;
-                    min_entity_id=p->id();
-                }
-            }
-            for(auto c:curves){
-                math::Point closest_pnt=node_loc;
-                c->project(closest_pnt);
-                double dist = node_loc.distance(closest_pnt);
-                if(dist<min_dist){
-                    //WARNING: Take care of this trick that is not good at all but mandatory to be staying on the
-                    // curve and not on the surface
-                    if(dist<1e-4)
-                        dist=0;
-                    min_dist =dist;
-                    min_entity_dim=1;
-                    min_entity_id=c->id();
-                }
-            }
-            for(auto s:surfaces){
-                math::Point closest_pnt=node_loc;
-                s->project(closest_pnt);
-                double dist = node_loc.distance(closest_pnt);
-                if(dist<min_dist){
-                    min_dist =dist;
-                    min_entity_dim=2;
-                    min_entity_id=s->id();
-                }
-            }
-
-            if(min_entity_dim==0){
-                on_pnt++;
-                linker.linkNodeToPoint(n_id,min_entity_id);
-            }
-            else if (min_entity_dim==1){
-                on_curve++;
-                linker.linkNodeToCurve(n_id,min_entity_id);
-            }
-            else if (min_entity_dim==2){
-                on_surf++;
-                linker.linkNodeToSurface(n_id,min_entity_id);
-            }
-            else{
-                throw GMDSException("Link error for classifying a node");
-            }
-
-        }
-    }
-    //==================================================================
-    // PERFORM THE MESH SMOOTHING NOW
-    //==================================================================
-    smoothy::LaplacianSmoother smoother(&linker);
-    smoother.smoothCurves(nb_iterations);
-    smoother.smoothSurfaces(nb_iterations);
-    smoother.smoothVolumes(nb_iterations);
-
-    ASSERT_TRUE(true);
+	// WE WRITE
+	Mesh m(gmds::MeshModel(DIM3 |  F | N | F2N | N2F));
+
+	GridBuilder gb(&m,2);
+
+	gb.execute(4,1.0,4,1.0);
+
+	MeshDoctor doc(&m);
+	doc.updateUpwardConnectivity();
+	smoothy::LaplacianSmoother2UC smoother(&m);
+	smoother.setNbIterations(1);
+
+	ASSERT_TRUE(smoother.isValid());
+	// FIRST WE MOVE A SINGLE NODE
+	std::vector<TCellID> to_move;
+	to_move.push_back(5);
+	m.get<Node>(5).setXYZ(0.5,0.5,0);
+
+	smoother.setNodes(to_move);
+	ASSERT_NEAR(m.get<Node>(5).point().X(), 0.5, 0.01);
+	ASSERT_NEAR(m.get<Node>(5).point().Y(), 0.5, 0.01);
+
+	smoother.smooth();
+	ASSERT_NEAR(m.get<Node>(5).point().X(), 1, 0.01);
+	ASSERT_NEAR(m.get<Node>(5).point().Y(), 1, 0.01);
+
+	// Now we move the four inner nodes
+	to_move.push_back(6);
+	to_move.push_back(9);
+	to_move.push_back(10);
+
+	m.get<Node>(5).setXYZ(0.5,0.5,0);
+	m.get<Node>(6).setXYZ(0.5,0.5,0);
+	m.get<Node>(9).setXYZ(0.5,0.5,0);
+	m.get<Node>(10).setXYZ(0.5,0.5,0);
+
+	smoother.setNbIterations(10);
+	smoother.setNodes(to_move);
+	smoother.smooth();
+	ASSERT_NEAR(m.get<Node>(5).point().X(), 1, 0.01);
+	ASSERT_NEAR(m.get<Node>(5).point().Y(), 1, 0.01);
+	ASSERT_NEAR(m.get<Node>(6).point().X(), 1, 0.01);
+	ASSERT_NEAR(m.get<Node>(6).point().Y(), 2, 0.01);
+	ASSERT_NEAR(m.get<Node>(9).point().X(), 2, 0.01);
+	ASSERT_NEAR(m.get<Node>(9).point().Y(), 1, 0.01);
+	ASSERT_NEAR(m.get<Node>(10).point().X(), 2, 0.01);
+	ASSERT_NEAR(m.get<Node>(10).point().Y(), 2, 0.01);
+
 }