diff --git a/Apps/Examples/viewer.cpp b/Apps/Examples/viewer.cpp
index c603cedc75abee69d79f9763666e4d5c375d0449..4616bd3deb027708dec591a71ee54f7690392db7 100644
--- a/Apps/Examples/viewer.cpp
+++ b/Apps/Examples/viewer.cpp
@@ -272,31 +272,31 @@ void Viewer::cb_keyPress(int keycode)
 		if(!pos2.isValid())
 			pos2 = myMap.addAttribute<VEC3, VERTEX>("pos2") ;
 
-		foreach_cell_EvenOddd<VERTEX>(myMap, [&] (Vertex d)
-		{
-			pos2[d] = VEC3(0,0,0);
-			int nb=0;
-			foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
-			{
-				pos2[d] += position[e];
-				nb++;
-			});
-			pos2[d]/=nb;
-		},
-		[&] (Vertex d)
-		{
-			position[d] = VEC3(0,0,0);
-			int nb=0;
-			foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
-			{
-				position[d] += pos2[e];
-				nb++;
-			});
-			position[d]/=nb;
-		},
-		3);
-
-		std::cout << "Even/Odd "<< ch.elapsed()<< " ms "<< std::endl;
+//		foreach_cell_EvenOddd<VERTEX>(myMap, [&] (Vertex d)
+//		{
+//			pos2[d] = VEC3(0,0,0);
+//			int nb=0;
+//			foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
+//			{
+//				pos2[d] += position[e];
+//				nb++;
+//			});
+//			pos2[d]/=nb;
+//		},
+//		[&] (Vertex d)
+//		{
+//			position[d] = VEC3(0,0,0);
+//			int nb=0;
+//			foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
+//			{
+//				position[d] += pos2[e];
+//				nb++;
+//			});
+//			position[d]/=nb;
+//		},
+//		3);
+
+//		std::cout << "Even/Odd "<< ch.elapsed()<< " ms "<< std::endl;
 		Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
 		m_positionVBO->updateData(position) ;
 		m_normalVBO->updateData(normal) ;
@@ -460,22 +460,32 @@ void Viewer::cb_keyPress(int keycode)
 		Utils::Chrono ch;
 		ch.start();
 
-		TraversorCell<MAP, VERTEX> trav(myMap,true);
-		TraversorCellEven<MAP, VERTEX> tr1(trav);
-		TraversorCellOdd<MAP, VERTEX> tr2(trav);
+		for (unsigned int i=0; i<4; ++i)
+			Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
+		std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices "<< ch.elapsed()<< " ms "<< std::endl;
 
-		for(unsigned int i=0; i<5; ++i)
-		{
-			for (Cell<VERTEX> v = tr1.begin(), e = tr1.end(); v.dart != e.dart; v = tr1.next())
-			{
-				normal[v][0] = 0.0f;
-			}
-			for (Cell<VERTEX> v = tr2.begin(), e = tr2.end(); v.dart != e.dart; v = tr2.next())
+		ch.start();
+		for (unsigned int i=0; i<4; ++i)
+			Parallel::foreach_cell<VERTEX>(myMap,[&](Vertex v, unsigned int th)
 			{
-				normal[v][0] = 0.0f;
-			}
-		}
-		std::cout << "Timing 5 traversors even/odd "<< ch.elapsed()<< " ms "<< std::endl;
+				normal[v] = Algo::Surface::Geometry::vertexNormal<PFP>(myMap,v,position);
+			},4,false,FORCE_CELL_MARKING);
+
+		std::cout << "Parallel::foreach_cell "<< ch.elapsed()<< " ms "<< std::endl;
+
+//		ch.start();
+//		Parallel::foreach_cell_EO<VERTEX>(myMap,[&](Vertex v, unsigned int thr)
+//		{
+//			normal[v] = Algo::Surface::Geometry::vertexNormal<PFP>(myMap,v,position);
+//		},
+//		[&](Vertex v, unsigned int th)
+//		{
+//			normal[v] = Algo::Surface::Geometry::vertexNormal<PFP>(myMap,v,position);
+//		},2,4,false,FORCE_CELL_MARKING);
+
+//		std::cout << "Parallel::foreach_cell_EO "<< ch.elapsed()<< " ms "<< std::endl;
+
+
 	}
 		break;
 
diff --git a/include/Algo/Geometry/area.hpp b/include/Algo/Geometry/area.hpp
index 438ec7fd5c0e8a8ca7d3964ae45e79690847ac8e..77ec75e8a9199ed50c78441011760e13010e1174 100644
--- a/include/Algo/Geometry/area.hpp
+++ b/include/Algo/Geometry/area.hpp
@@ -201,73 +201,49 @@ void computeVoronoiAreaVertices(typename PFP::MAP& map, const VertexAttribute<ty
 namespace Parallel
 {
 
-template <typename PFP>
-class FunctorConvexFaceArea: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& m_position;
-	 FaceAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& m_area;
-public:
-	 FunctorConvexFaceArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, FaceAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& area):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_area[d] = convexFaceArea<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
 template <typename PFP>
 void computeAreaFaces(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, FaceAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& area, unsigned int nbth)
 {
-	FunctorConvexFaceArea<PFP> funct(map,position,area);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,FACE>(map, funct, nbth, false);
+//	if (map.isOrbitEmbedded<FACE>())
+//	{
+//		Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+//		{
+//			area[f] = convexFaceArea<PFP>(map, f, position) ;
+//		},nbth,false,FORCE_CELL_MARKING);
+//	}
+//	else
+//	{
+//		Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+//		{
+//			area[f] = convexFaceArea<PFP>(map, f, position) ;
+//		},nbth,false,AUTO);
+//	}
+
+	// TODO A REMPLACER QUAND PLGTS CHANGES
+
+	CGoGN::Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+	{
+		area[f] = convexFaceArea<PFP>(map, f, position) ;
+	},nbth,false,AUTO);
 }
 
-template <typename PFP>
-class FunctorVertexOneRingArea: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& m_position;
-	 VertexAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& m_area;
-public:
-	 FunctorVertexOneRingArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, VertexAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& area):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_area[d] = vertexOneRingArea<PFP>(this->m_map, d, m_position) ;
-	}
-};
 
 template <typename PFP>
 void computeOneRingAreaVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, VertexAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& area, unsigned int nbth)
 {
-	FunctorConvexFaceArea<PFP> funct(map,position,area);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false);
-}
-
-template <typename PFP>
-class FunctorVertexVoronoiArea: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& m_position;
-	 VertexAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& m_area;
-public:
-	 FunctorVertexVoronoiArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, VertexAttribute<typename PFP::REAL, typename PFP::MAP::IMPL>& area):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
+	CGoGN::Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int thr)
 	{
-		m_area[d] = vertexVoronoiArea<PFP>(this->m_map, d, m_position) ;
-	}
-};
+		area[v] = vertexOneRingArea<PFP>(map, v, position) ;
+	},nbth,false,FORCE_CELL_MARKING);
+}
 
 template <typename PFP>
 void computeVoronoiAreaVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP>& position, VertexAttribute<typename PFP::REAL, typename PFP::MAP>& area, unsigned int nbth)
 {
-	FunctorConvexFaceArea<PFP> funct(map,position,area);
-	Algo::Parallel::foreach_cell<typename PFP::MAP, VERTEX>(map, funct, nbth, false);
+	CGoGN::Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int thr)
+	{
+		area[v] = vertexVoronoiArea<PFP>(map, v, position) ;
+	},nbth,false,FORCE_CELL_MARKING);
 }
 
 } // namespace Parallel
diff --git a/include/Algo/Geometry/centroid.hpp b/include/Algo/Geometry/centroid.hpp
index de903dd3ebeddc78fb93f5c5d340eb10a2c24f4a..baef25b6f636d7fd74ceaf08afeb3c1a463f1141 100644
--- a/include/Algo/Geometry/centroid.hpp
+++ b/include/Algo/Geometry/centroid.hpp
@@ -169,71 +169,25 @@ void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const V_ATT& po
 namespace Parallel
 {
 
-template <typename PFP, typename V_ATT, typename F_ATT>
-class FunctorComputeCentroidFaces: public FunctorMapThreaded<typename PFP::MAP>
-{
-	 const V_ATT& m_position;
-	 F_ATT& m_fcentroid;
-
-public:
-	 FunctorComputeCentroidFaces<PFP,V_ATT,F_ATT>( typename PFP::MAP& map, const V_ATT& position, F_ATT& fcentroid):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_fcentroid(fcentroid)
-	 { }
-
-	void run(Dart d, unsigned int /*threadID*/)
-	{
-		m_fcentroid[d] = faceCentroid<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
-template <typename PFP, typename V_ATT, typename F_ATT>
-class FunctorComputeCentroidELWFaces: public FunctorMapThreaded<typename PFP::MAP>
-{
-	const V_ATT& m_position;
-	F_ATT& m_fcentroid;
-
-public:
-	 FunctorComputeCentroidELWFaces<PFP,V_ATT,F_ATT>( typename PFP::MAP& map, const V_ATT& position, F_ATT& fcentroid):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_fcentroid(fcentroid)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_fcentroid[d] = faceCentroidELW<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
-template <typename PFP, typename V_ATT>
-class FunctorComputeNeighborhoodCentroidVertices: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const V_ATT& m_position;
-	 V_ATT& m_vcentroid;
-
-public:
-	 FunctorComputeNeighborhoodCentroidVertices<PFP,V_ATT>( typename PFP::MAP& map, const V_ATT& position, V_ATT& vcentroid):
-		 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vcentroid(vcentroid)
-	 { }
-
-	void run(Dart d, unsigned int /*threadID*/)
-	{
-		m_vcentroid[d] = vertexNeighborhoodCentroid<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
 template <typename PFP, typename V_ATT, typename F_ATT>
 void computeCentroidFaces(typename PFP::MAP& map, const V_ATT& position, F_ATT& face_centroid,
-		unsigned int nbth, unsigned int current_thread)
+		unsigned int nbth)
 {
-	FunctorComputeCentroidFaces<PFP,V_ATT,F_ATT> funct(map,position,face_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,FACE>(map, funct, nbth, false, current_thread);
+	CGoGN::Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+	{
+		face_centroid[f] = faceCentroid<PFP>(map, f, position) ;
+	},nbth,false,AUTO);
 }
 
 template <typename PFP, typename V_ATT, typename F_ATT>
 void computeCentroidELWFaces(typename PFP::MAP& map, const V_ATT& position, F_ATT& face_centroid,
 		unsigned int nbth, unsigned int current_thread)
 {
-	FunctorComputeCentroidELWFaces<PFP,V_ATT,F_ATT> funct(map,position,face_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,FACE>(map, funct, nbth, false, current_thread);
+	CGoGN::Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+	{
+		face_centroid[f] = faceCentroidELW<PFP>(map, f, position) ;
+	},nbth,false,AUTO);
+
 }
 
 template <typename PFP, typename V_ATT>
@@ -241,8 +195,10 @@ void computeNeighborhoodCentroidVertices(typename PFP::MAP& map,
 		const V_ATT& position, V_ATT& vertex_centroid,
 		unsigned int nbth, unsigned int current_thread)
 {
-	FunctorComputeNeighborhoodCentroidVertices<PFP,V_ATT> funct(map,position,vertex_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false);
+	CGoGN::Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int thr)
+	{
+		vertex_centroid[v] = vertexNeighborhoodCentroid<PFP>(map, v, position) ;
+	},nbth,false,FORCE_CELL_MARKING);
 }
 
 } // namespace Parallel
@@ -308,79 +264,35 @@ void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const V_ATT& po
 namespace Parallel
 {
 
-template <typename PFP, typename V_ATT, typename W_ATT>
-class FunctorComputeCentroidVolumes: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const V_ATT& m_position;
-	 W_ATT& m_vol_centroid;
-
-public:
-	 FunctorComputeCentroidVolumes<PFP,V_ATT,W_ATT>( typename PFP::MAP& map, const V_ATT& position, W_ATT& vol_centroid):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vol_centroid(vol_centroid)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_vol_centroid[d] = Surface::Geometry::volumeCentroid<PFP,V_ATT,W_ATT>(this->m_map, d, m_position,threadID) ;
-	}
-};
-
 template <typename PFP, typename V_ATT, typename W_ATT>
 void computeCentroidVolumes(typename PFP::MAP& map, const V_ATT& position, W_ATT& vol_centroid,	unsigned int nbth)
 {
-	FunctorComputeCentroidVolumes<PFP,V_ATT,W_ATT> funct(map,position,vol_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VOLUME>(map, funct, nbth, true);
-}
-
-template <typename PFP, typename V_ATT, typename W_ATT>
-class FunctorComputeCentroidELWVolumes: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const V_ATT& m_position;
-	 W_ATT& m_vol_centroid;
-
-public:
-	 FunctorComputeCentroidELWVolumes<PFP,V_ATT,W_ATT>( typename PFP::MAP& map, const V_ATT& position, W_ATT& vol_centroid):
-		 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vol_centroid(vol_centroid)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
+	CGoGN::Parallel::foreach_cell<VOLUME>(map,[&](Vol v, unsigned int thr)
 	{
-		m_vol_centroid[d] = Surface::Geometry::volumeCentroidELW<PFP,V_ATT>(this->m_map, d, m_position, threadID) ;
-	}
-};
+		vol_centroid[v] = Surface::Geometry::volumeCentroid<PFP,V_ATT,W_ATT>(map, v, position, thr) ;
+	},nbth,true,AUTO);
+}
 
 template <typename PFP, typename V_ATT, typename W_ATT>
 void computeCentroidELWVolumes(typename PFP::MAP& map,
 		const V_ATT& position, W_ATT& vol_centroid,
 		unsigned int nbth)
 {
-	FunctorComputeCentroidELWVolumes<PFP,V_ATT,W_ATT> funct(map,position,vol_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VOLUME>(map, funct, nbth, true);
+	CGoGN::Parallel::foreach_cell<VOLUME>(map,[&](Vol v, unsigned int thr)
+	{
+		vol_centroid[v] = Surface::Geometry::volumeCentroidELW<PFP,V_ATT>(map, v, position, thr) ;
+	},nbth,true,AUTO);
 }
 
-template <typename PFP, typename V_ATT>
-class FunctorComputeNeighborhoodCentroidVertices: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const V_ATT& m_position;
-	 V_ATT& m_vcentroid;
-
-public:
-	 FunctorComputeNeighborhoodCentroidVertices<PFP,V_ATT>( typename PFP::MAP& map, const V_ATT& position, V_ATT& vcentroid):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vcentroid(vcentroid)
-	 { }
-
-	void run(Dart d, unsigned int /*threadID*/)
-	{
-		m_vcentroid[d] = vertexNeighborhoodCentroid<PFP,V_ATT>(this->m_map, d, m_position) ;
-	}
-};
 
 template <typename PFP, typename V_ATT>
 void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const V_ATT& position, V_ATT& vertex_centroid,
 		unsigned int nbth)
 {
-	FunctorComputeNeighborhoodCentroidVertices<PFP,V_ATT> funct(map,position,vertex_centroid);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false);
+	CGoGN::Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int thr)
+	{
+		vertex_centroid[v] = Volume::Geometry::vertexNeighborhoodCentroid<PFP,V_ATT>(map, v, position,thr) ;
+	},nbth,true,FORCE_CELL_MARKING);
 }
 
 } // namespace Parallel
diff --git a/include/Algo/Geometry/curvature.hpp b/include/Algo/Geometry/curvature.hpp
index 7a2c3541cb0f1a12a516a8dbfd8f414264c58b0c..64f5c1edd0d5cc006c67f8a71aaabacea1843fba 100644
--- a/include/Algo/Geometry/curvature.hpp
+++ b/include/Algo/Geometry/curvature.hpp
@@ -602,54 +602,6 @@ void normalCycles_ProjectTensor(Geom::Matrix<3,3,typename PFP::REAL>& tensor, co
 
 namespace Parallel
 {
-
-template <typename PFP>
-class FunctorComputeCurvatureVertices_NormalCycles: public FunctorMapThreaded<typename PFP::MAP >
-{
-	typedef typename PFP::MAP MAP ;
-	typedef typename PFP::MAP::IMPL MAP_IMPL ;
-	typedef typename PFP::VEC3 VEC3 ;
-	typedef typename PFP::REAL REAL ;
-
-	REAL m_radius;
-	const VertexAttribute<VEC3, MAP_IMPL>& m_position;
-	const VertexAttribute<VEC3, MAP_IMPL>& m_normal;
-	const EdgeAttribute<REAL, MAP_IMPL>& m_edgeangle;
-	VertexAttribute<REAL, MAP_IMPL>& m_kmax;
-	VertexAttribute<REAL, MAP_IMPL>& m_kmin;
-	VertexAttribute<VEC3, MAP_IMPL>& m_Kmax;
-	VertexAttribute<VEC3, MAP_IMPL>& m_Kmin;
-	VertexAttribute<VEC3, MAP_IMPL>& m_Knormal;
-public:
-	 FunctorComputeCurvatureVertices_NormalCycles(
-		MAP& map,
-		REAL radius,
-		const VertexAttribute<VEC3, MAP_IMPL>& position,
-		const VertexAttribute<VEC3, MAP_IMPL>& normal,
-		const EdgeAttribute<REAL, MAP_IMPL>& edgeangle,
-		VertexAttribute<REAL, MAP_IMPL>& kmax,
-		VertexAttribute<REAL, MAP_IMPL>& kmin,
-		VertexAttribute<VEC3, MAP_IMPL>& Kmax,
-		VertexAttribute<VEC3, MAP_IMPL>& Kmin,
-		VertexAttribute<VEC3, MAP_IMPL>& Knormal):
-	  FunctorMapThreaded<MAP>(map),
-	  m_radius(radius),
-	  m_position(position),
-	  m_normal(normal),
-	  m_edgeangle(edgeangle),
-	  m_kmax(kmax),
-	  m_kmin(kmin),
-	  m_Kmax(Kmax),
-	  m_Kmin(Kmin),
-	  m_Knormal(Knormal)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		computeCurvatureVertex_NormalCycles<PFP>(this->m_map, d, m_radius, m_position, m_normal, m_edgeangle, m_kmax, m_kmin, m_Kmax, m_Kmin, m_Knormal, threadID) ;
-	}
-};
-
 template <typename PFP>
 void computeCurvatureVertices_NormalCycles(
 	typename PFP::MAP& map,
@@ -681,50 +633,13 @@ void computeCurvatureVertices_NormalCycles(
 		map.template initAllOrbitsEmbedding<FACE>();
 	}
 
-	FunctorComputeCurvatureVertices_NormalCycles<PFP> funct(map, radius, position, normal, edgeangle, kmax, kmin, Kmax, Kmin, Knormal);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, true);
+	Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int threadID)
+	{
+		computeCurvatureVertex_NormalCycles<PFP>(map, v, radius, position, normal, edgeangle, kmax, kmin, Kmax, Kmin, Knormal, threadID) ;
+	},nbth,true,FORCE_CELL_MARKING);
 }
 
 
-
-template <typename PFP>
-class FunctorComputeCurvatureVertices_QuadraticFitting: public FunctorMapThreaded<typename PFP::MAP >
-{
-	typedef typename PFP::MAP MAP ;
-	typedef typename PFP::MAP::IMPL MAP_IMPL ;
-	typedef typename PFP::VEC3 VEC3 ;
-	typedef typename PFP::REAL REAL ;
-
-	const VertexAttribute<VEC3, MAP_IMPL>& m_position;
-	const VertexAttribute<VEC3, MAP_IMPL>& m_normal;
-	VertexAttribute<REAL, MAP_IMPL>& m_kmax;
-	VertexAttribute<REAL, MAP_IMPL>& m_kmin;
-	VertexAttribute<VEC3, MAP_IMPL>& m_Kmax;
-	VertexAttribute<VEC3, MAP_IMPL>& m_Kmin;
-public:
-	 FunctorComputeCurvatureVertices_QuadraticFitting(
-		MAP& map,
-		const VertexAttribute<VEC3, MAP_IMPL>& position,
-		const VertexAttribute<VEC3, MAP_IMPL>& normal,
-		VertexAttribute<REAL, MAP_IMPL>& kmax,
-		VertexAttribute<REAL, MAP_IMPL>& kmin,
-		VertexAttribute<VEC3, MAP_IMPL>& Kmax,
-		VertexAttribute<VEC3, MAP_IMPL>& Kmin):
-	  FunctorMapThreaded<MAP>(map),
-	  m_position(position),
-	  m_normal(normal),
-	  m_kmax(kmax),
-	  m_kmin(kmin),
-	  m_Kmax(Kmax),
-	  m_Kmin(Kmin)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		computeCurvatureVertex_QuadraticFitting<PFP>(this->m_map, d, m_position, m_normal, m_kmax, m_kmin, m_Kmax, m_Kmin) ;
-	}
-};
-
 template <typename PFP>
 void computeCurvatureVertices_QuadraticFitting(
 	typename PFP::MAP& map,
@@ -736,8 +651,11 @@ void computeCurvatureVertices_QuadraticFitting(
 	VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& Kmin,
 	unsigned int nbth)
 {
-	FunctorComputeCurvatureVertices_QuadraticFitting<PFP> funct(map, position, normal, kmax, kmin, Kmax, Kmin);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, true);
+	Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int threadID)
+	{
+		computeCurvatureVertex_QuadraticFitting<PFP>(map, v, position, normal, kmax, kmin, Kmax, Kmin, threadID) ;
+	},nbth,true,FORCE_CELL_MARKING);
+
 }
 
 } // namespace Parallel
diff --git a/include/Algo/Geometry/normal.hpp b/include/Algo/Geometry/normal.hpp
index 2801d6c076158629b6509796dfe184a75956bec3..e699b76baaa23a1ca5d39d874f9b5ba0f95471aa 100644
--- a/include/Algo/Geometry/normal.hpp
+++ b/include/Algo/Geometry/normal.hpp
@@ -163,84 +163,6 @@ void computeNormalVertices(typename PFP::MAP& map, const V_ATT& position, V_ATT&
 }
 
 
-
-namespace Parallel
-{
-
-template <typename PFP, typename V_ATT>
-class FunctorComputeNormalVertices : public FunctorMapThreaded<typename PFP::MAP>
-{
-	const V_ATT& m_position;
-	V_ATT& m_normal;
-public:
-	FunctorComputeNormalVertices<PFP,V_ATT>(typename PFP::MAP& map, const V_ATT& position, V_ATT& normal):
-		FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_normal(normal)
-	{ }
-
-	void run(Dart d, unsigned int /*threadID*/)
-	{
-		m_normal[d] = vertexNormal<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
-template <typename PFP, typename V_ATT>
-void computeNormalVertices(typename PFP::MAP& map, const V_ATT& position, V_ATT& normal, unsigned int nbth)
-{
-	FunctorComputeNormalVertices<PFP,V_ATT> funct(map, position, normal);
-	Algo::Parallel::foreach_cell<typename PFP::MAP, VERTEX>(map, funct, nbth, false);
-}
-
-template <typename PFP, typename V_ATT, typename F_ATT>
-class FunctorComputeNormalFaces : public FunctorMapThreaded<typename PFP::MAP>
-{
-	const V_ATT& m_position;
-	F_ATT& m_normal;
-public:
-	FunctorComputeNormalFaces<PFP,V_ATT,F_ATT>(typename PFP::MAP& map, const V_ATT& position, F_ATT& normal):
-		FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_normal(normal)
-	{ }
-
-	void run(Dart d, unsigned int /*threadID*/)
-	{
-		m_normal[d] = faceNormal<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
-template <typename PFP, typename V_ATT, typename F_ATT>
-void computeNormalFaces(typename PFP::MAP& map, const V_ATT& position, F_ATT& normal, unsigned int nbth)
-{
-	FunctorComputeNormalFaces<PFP,V_ATT,F_ATT> funct(map, position, normal);
-	Algo::Parallel::foreach_cell<typename PFP::MAP, FACE>(map, funct, nbth, false);
-}
-
-template <typename PFP, typename V_ATT, typename E_ATT>
-class FunctorComputeAngleBetweenNormalsOnEdge: public FunctorMapThreaded<typename PFP::MAP>
-{
-	const V_ATT& m_position;
-	E_ATT& m_angles;
-
-public:
-	FunctorComputeAngleBetweenNormalsOnEdge<PFP,V_ATT,E_ATT>( typename PFP::MAP& map, const V_ATT& position, E_ATT& angles):
-		FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_angles(angles)
-	{ }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_angles[d] = computeAngleBetweenNormalsOnEdge<PFP>(this->m_map, d, m_position) ;
-	}
-};
-
-template <typename PFP, typename V_ATT, typename E_ATT>
-void computeAnglesBetweenNormalsOnEdges(typename PFP::MAP& map, const V_ATT& position, E_ATT& angles, unsigned int nbth)
-{
-	FunctorComputeAngleBetweenNormalsOnEdge<PFP,V_ATT,E_ATT> funct(map,position,angles);
-	Algo::Parallel::foreach_cell<typename PFP::MAP,EDGE>(map, funct, nbth, false);
-}
-
-} // namespace Parallel
-
-
-
 template <typename PFP, typename V_ATT>
 typename PFP::REAL computeAngleBetweenNormalsOnEdge(typename PFP::MAP& map, Edge e, const V_ATT& position)
 {
@@ -284,6 +206,42 @@ void computeAnglesBetweenNormalsOnEdges(typename PFP::MAP& map, const V_ATT& pos
 	false, thread);
 }
 
+
+
+namespace Parallel
+{
+
+template <typename PFP, typename V_ATT>
+void computeNormalVertices(typename PFP::MAP& map, const V_ATT& position, V_ATT& normal, unsigned int nbth)
+{
+	CGoGN::Parallel::foreach_cell<VERTEX>(map,[&](Vertex v, unsigned int thr)
+	{
+		normal[v] = vertexNormal<PFP>(map, v, position) ;
+	},nbth,true,FORCE_CELL_MARKING);
+}
+
+template <typename PFP, typename V_ATT, typename F_ATT>
+void computeNormalFaces(typename PFP::MAP& map, const V_ATT& position, F_ATT& normal, unsigned int nbth)
+{
+	CGoGN::Parallel::foreach_cell<FACE>(map,[&](Face f, unsigned int thr)
+	{
+		normal[f] = faceNormal<PFP>(map, f, position) ;
+	},nbth,true,AUTO);
+}
+
+
+template <typename PFP, typename V_ATT, typename E_ATT>
+void computeAnglesBetweenNormalsOnEdges(typename PFP::MAP& map, const V_ATT& position, E_ATT& angles, unsigned int nbth)
+{
+	CGoGN::Parallel::foreach_cell<EDGE>(map,[&](Edge e, unsigned int thr)
+	{
+		angles[e] = computeAngleBetweenNormalsOnEdge<PFP>(map, e, position) ;
+	},nbth,true,AUTO);
+}
+
+} // namespace Parallel
+
+
 } // namespace Geometry
 
 } // namespace Surface
diff --git a/include/Algo/Geometry/volume.hpp b/include/Algo/Geometry/volume.hpp
index d8f61618c89b538bb2559e83521fd26eebb393a3..f357000a95a95e9ca4935b383ba6096c44ce9414 100644
--- a/include/Algo/Geometry/volume.hpp
+++ b/include/Algo/Geometry/volume.hpp
@@ -138,50 +138,29 @@ typename PFP::REAL totalVolume(typename PFP::MAP& map, const VertexAttribute<typ
 namespace Parallel
 {
 
-template <typename PFP>
-class FunctorTotalVolume: public FunctorMapThreaded<typename PFP::MAP >
-{
-	 const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& m_position;
-	 double m_vol;
-
-public:
-	 FunctorTotalVolume<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position):
-	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vol(0.0)
-	 { }
-
-	void run(Dart d, unsigned int threadID)
-	{
-		m_vol += convexPolyhedronVolume<PFP>(this->m_map, d, m_position, threadID) ;
-	}
-
-	double getVol() const
-	{
-		return m_vol;
-	}
-};
-
 template <typename PFP>
 typename PFP::REAL totalVolume(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP::IMPL>& position, unsigned int nbth)
 {
+	// get number of thread of processor if needed
 	if (nbth == 0)
-		nbth = Algo::Parallel::optimalNbThreads();
+		nbth = boost::thread::hardware_concurrency();
 
-	std::vector<FunctorMapThreaded<typename PFP::MAP>*> functs;
-	for (unsigned int i = 0; i < nbth; ++i)
-	{
-		functs.push_back(new FunctorTotalVolume<PFP>(map,position));
-	}
+	// allocate a vector of 1 accumulator for each thread
+	std::vector<typename PFP::REAL> vols(nbth,0.0);
 
-	double total = 0.0;
+	// foreach volume
+	CGoGN::Parallel::foreach_cell<VOLUME>(map,[&](Vol v, unsigned int thr)
+	{
+		// add volume to the thread accumulator
+		vols[thr-1] += convexPolyhedronVolume<PFP>(map, v, position, thr) ;
+	},nbth);
 
-	Algo::Parallel::foreach_cell<typename PFP::MAP,VOLUME>(map, functs, true);
+	// compute the sum of volumes
+	typename PFP::REAL total(0);
+	for (unsigned int i=0; i< nbth; ++i )
+		total += vols[i];
 
-	for (unsigned int i=0; i < nbth; ++i)
-	{
-		total += reinterpret_cast<FunctorTotalVolume<PFP>*>(functs[i])->getVol();
-		delete functs[i];
-	}
-	return typename PFP::REAL(total);
+	return total;
 }
 
 } // namespace Parallel
diff --git a/include/Topology/generic/traversor/traversorCell.h b/include/Topology/generic/traversor/traversorCell.h
index bdc5785f24e8475abef3782759087da0e353ddba..76ba3cf23b7f8976053a16223642d16b88004fba 100644
--- a/include/Topology/generic/traversor/traversorCell.h
+++ b/include/Topology/generic/traversor/traversorCell.h
@@ -115,161 +115,22 @@ public:
  * Executes function f on each ORBIT
  */
 template <unsigned int ORBIT, typename MAP, typename FUNC>
-inline void foreach_cell(const MAP& map, FUNC f, TraversalOptim opt = AUTO, unsigned int thread = 0)
-{
-	switch(opt)
-	{
-	case FORCE_DART_MARKING:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			f(c);
-	}
-	break;
-	case FORCE_CELL_MARKING:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			f(c);
-	}
-	break;
-	case FORCE_QUICK_TRAVERSAL:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			f(c);
-	}
-	break;
-	case AUTO:
-	default:
-	{
-		TraversorCell<MAP, ORBIT,AUTO> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			f(c);
-	}
-	break;
-
-	}
-}
+inline void foreach_cell(const MAP& map, FUNC f, TraversalOptim opt = AUTO, unsigned int thread = 0);
+
 
 /*
  * Executes function f on each ORBIT until f returns false
  */
 template <unsigned int ORBIT, typename MAP, typename FUNC>
-inline void foreach_cell_until(const MAP& map, FUNC f, TraversalOptim opt = AUTO, unsigned int thread = 0)
-{
-	switch(opt)
-	{
-	case FORCE_DART_MARKING:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			if (!f(c))
-				break;
-	}
-	break;
-	case FORCE_CELL_MARKING:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			if (!f(c))
-				break;
-	}
-	break;
-	case FORCE_QUICK_TRAVERSAL:
-	{
-		TraversorCell<MAP, ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			if (!f(c))
-				break;
-	}
-	break;
-	case AUTO:
-	default:
-	{
-		TraversorCell<MAP, ORBIT,AUTO> trav(map, false, thread);
-		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-			if (!f(c))
-				break;
-	}
-	break;
-	}
-}
+inline void foreach_cell_until(const MAP& map, FUNC f, TraversalOptim opt = AUTO, unsigned int thread = 0);
 
 /*
  * Executes function f on each ORBIT, then
  * execute function g on each ORBIT
  * Optimization on marking (even pass marking, odd pass unmarking)
  */
-template <unsigned int ORBIT, typename MAP, typename FUNC, typename FUNC2>
-inline void foreach_cell_EvenOddd(const MAP& map, FUNC f, FUNC2 g, unsigned int nbpasses=1, TraversalOptim opt = AUTO, unsigned int thread = 0)
-{
-	switch(opt)
-	{
-	case FORCE_DART_MARKING:
-	{
-		TraversorCell<MAP,ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
-		TraversorCellEven<MAP,ORBIT,FORCE_DART_MARKING> tr1(trav);
-		TraversorCellOdd<MAP,ORBIT,FORCE_DART_MARKING> tr2(trav);
-
-		for (unsigned int i=0; i<nbpasses; ++i)
-		{
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				f(c);
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				g(c);
-		}
-	}
-	break;
-	case FORCE_CELL_MARKING:
-	{
-		TraversorCell<MAP,ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
-		TraversorCellEven<MAP,ORBIT,FORCE_CELL_MARKING> tr1(trav);
-		TraversorCellOdd<MAP,ORBIT, FORCE_CELL_MARKING> tr2(trav);
-
-		for (unsigned int i=0; i<nbpasses; ++i)
-		{
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				f(c);
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				g(c);
-		}
-	}
-	break;
-	case FORCE_QUICK_TRAVERSAL:
-	{
-		TraversorCell<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
-		TraversorCellEven<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> tr1(trav);
-		TraversorCellOdd<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> tr2(trav);
-
-		for (unsigned int i=0; i<nbpasses; ++i)
-		{
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				f(c);
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				g(c);
-		}
-	}
-	break;
-	case AUTO:
-	default:
-	{
-		TraversorCell<MAP,ORBIT,AUTO> trav(map, false, thread);
-		TraversorCellEven<MAP,ORBIT,AUTO> tr1(trav);
-		TraversorCellOdd<MAP,ORBIT,AUTO> tr2(trav);
-
-		for (unsigned int i=0; i<nbpasses; ++i)
-		{
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				f(c);
-			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
-				g(c);
-		}
-	}
-	break;
-	}
-}
-
+//template <unsigned int ORBIT, typename MAP, typename FUNC, typename FUNC2>
+//void foreach_cell_EvenOddd(const MAP& map, FUNC f, FUNC2 g, unsigned int nbpasses=1, TraversalOptim opt = AUTO, unsigned int thread = 0);
 
 
 namespace Parallel
@@ -278,37 +139,37 @@ template <unsigned int ORBIT, typename MAP, typename FUNC>
 void foreach_cell(MAP& map, FUNC func, unsigned int nbth=0, bool needMarkers=true, TraversalOptim opt=AUTO);
 
 //template <unsigned int ORBIT, typename MAP, typename FUNC_E, typename FUNC_O>
-//void foreach_cell_EO(MAP& map, FUNC_E funcEven, FUNC_O funcOdd,unsigned int nbth=0, bool needMarkers=true, TraversalOptim opt = AUTO);
-
+//void foreach_cell_EO(MAP& map, FUNC_E funcEven, FUNC_O funcOdd, unsigned int nbPasses=1, unsigned int nbth=0, bool needMarkers=true, TraversalOptim opt = AUTO);
 
 }
 
-template <typename MAP>
-class TraversorV : public TraversorCell<MAP, VERTEX>
+
+template <typename MAP, TraversalOptim OPT=AUTO>
+class TraversorV : public TraversorCell<MAP, VERTEX,OPT>
 {
 public:
 	TraversorV(const MAP& m, unsigned int thread = 0) : TraversorCell<MAP, VERTEX>(m, false, thread)
 	{}
 };
 
-template <typename MAP>
-class TraversorE : public TraversorCell<MAP, EDGE>
+template <typename MAP, TraversalOptim OPT=AUTO>
+class TraversorE : public TraversorCell<MAP, EDGE,OPT>
 {
 public:
 	TraversorE(const MAP& m, unsigned int thread = 0) : TraversorCell<MAP, EDGE>(m, false, thread)
 	{}
 };
 
-template <typename MAP>
-class TraversorF : public TraversorCell<MAP, FACE>
+template <typename MAP, TraversalOptim OPT=AUTO>
+class TraversorF : public TraversorCell<MAP, FACE,OPT>
 {
 public:
 	TraversorF(const MAP& m, unsigned int thread = 0) : TraversorCell<MAP, FACE>(m, false, thread)
 	{}
 };
 
-template <typename MAP>
-class TraversorW : public TraversorCell<MAP, VOLUME>
+template <typename MAP, TraversalOptim OPT=AUTO>
+class TraversorW : public TraversorCell<MAP, VOLUME,OPT>
 {
 public:
 	TraversorW(const MAP& m, unsigned int thread = 0) : TraversorCell<MAP, VOLUME>(m, false, thread)
@@ -317,7 +178,6 @@ public:
 
 
 
-
 } // namespace CGoGN
 
 #include "Topology/generic/traversor/traversorCell.hpp"
diff --git a/include/Topology/generic/traversor/traversorCell.hpp b/include/Topology/generic/traversor/traversorCell.hpp
index b150319dca3d26e1942394bda93c017fe49af85f..546b55a42a550c4bd1a0868737ee2334927a32f7 100644
--- a/include/Topology/generic/traversor/traversorCell.hpp
+++ b/include/Topology/generic/traversor/traversorCell.hpp
@@ -74,9 +74,8 @@ TraversorCell<MAP, ORBIT,OPT>::TraversorCell(const MAP& map, bool forceDartMarke
 
 template <typename MAP, unsigned int ORBIT, TraversalOptim OPT>
 TraversorCell<MAP, ORBIT,OPT>::TraversorCell(const TraversorCell<MAP, ORBIT,OPT>& tc) :
-	m(tc.m), dmark(tc.dmark), cmark(tc.cmark),
-	quickTraversal(tc.quickTraversal), current(tc.current), firstTraversal(tc.firstTraversal),
-	dimension(tc.dimension)
+	m(tc.m), dimension(tc.dimension), cont( tc.cont), qCurrent(tc.qCurrent), dmark(tc.dmark), cmark(tc.cmark),
+	quickTraversal(tc.quickTraversal), current(tc.current), firstTraversal(tc.firstTraversal)
 {
 }
 
@@ -464,6 +463,159 @@ Cell<ORBIT> TraversorCellOdd<MAP, ORBIT,OPT>::next()
 
 
 
+template <unsigned int ORBIT, typename MAP, typename FUNC>
+inline void foreach_cell(const MAP& map, FUNC f, TraversalOptim opt, unsigned int thread)
+{
+	switch(opt)
+	{
+	case FORCE_DART_MARKING:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			f(c);
+	}
+	break;
+	case FORCE_CELL_MARKING:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			f(c);
+	}
+	break;
+	case FORCE_QUICK_TRAVERSAL:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			f(c);
+	}
+	break;
+	case AUTO:
+	default:
+	{
+		TraversorCell<MAP, ORBIT,AUTO> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			f(c);
+	}
+	break;
+
+	}
+}
+
+template <unsigned int ORBIT, typename MAP, typename FUNC>
+inline void foreach_cell_until(const MAP& map, FUNC f, TraversalOptim opt, unsigned int thread)
+{
+	switch(opt)
+	{
+	case FORCE_DART_MARKING:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			if (!f(c))
+				break;
+	}
+	break;
+	case FORCE_CELL_MARKING:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			if (!f(c))
+				break;
+	}
+	break;
+	case FORCE_QUICK_TRAVERSAL:
+	{
+		TraversorCell<MAP, ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			if (!f(c))
+				break;
+	}
+	break;
+	case AUTO:
+	default:
+	{
+		TraversorCell<MAP, ORBIT,AUTO> trav(map, false, thread);
+		for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+			if (!f(c))
+				break;
+	}
+	break;
+	}
+}
+
+
+//template <unsigned int ORBIT, typename MAP, typename FUNC, typename FUNC2>
+//inline void foreach_cell_EvenOdd(const MAP& map, FUNC f, FUNC2 g, unsigned int nbpasses, TraversalOptim opt, unsigned int thread)
+//{
+//	switch(opt)
+//	{
+//	case FORCE_DART_MARKING:
+//	{
+//		TraversorCell<MAP,ORBIT,FORCE_DART_MARKING> trav(map, false, thread);
+//		TraversorCellEven<MAP,ORBIT,FORCE_DART_MARKING> tr1(trav);
+//		TraversorCellOdd<MAP,ORBIT,FORCE_DART_MARKING> tr2(trav);
+
+//		for (unsigned int i=0; i<nbpasses; ++i)
+//		{
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				f(c);
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				g(c);
+//		}
+//	}
+//	break;
+//	case FORCE_CELL_MARKING:
+//	{
+//		TraversorCell<MAP,ORBIT,FORCE_CELL_MARKING> trav(map, false, thread);
+//		TraversorCellEven<MAP,ORBIT,FORCE_CELL_MARKING> tr1(trav);
+//		TraversorCellOdd<MAP,ORBIT, FORCE_CELL_MARKING> tr2(trav);
+
+//		for (unsigned int i=0; i<nbpasses; ++i)
+//		{
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				f(c);
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				g(c);
+//		}
+//	}
+//	break;
+//	case FORCE_QUICK_TRAVERSAL:
+//	{
+//		TraversorCell<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> trav(map, false, thread);
+//		TraversorCellEven<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> tr1(trav);
+//		TraversorCellOdd<MAP,ORBIT,FORCE_QUICK_TRAVERSAL> tr2(trav);
+
+//		for (unsigned int i=0; i<nbpasses; ++i)
+//		{
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				f(c);
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				g(c);
+//		}
+//	}
+//	break;
+//	case AUTO:
+//	default:
+//	{
+//		TraversorCell<MAP,ORBIT,AUTO> trav(map, false, thread);
+//		TraversorCellEven<MAP,ORBIT,AUTO> tr1(trav);
+//		TraversorCellOdd<MAP,ORBIT,AUTO> tr2(trav);
+
+//		for (unsigned int i=0; i<nbpasses; ++i)
+//		{
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				f(c);
+//			for (Cell<ORBIT> c = trav.begin(), e = trav.end(); c.dart != e.dart; c = trav.next())
+//				g(c);
+//		}
+//	}
+//	break;
+//	}
+//}
+
+
+
+
+
 namespace Parallel
 {
 
@@ -494,6 +646,7 @@ public:
 		{
 			for (typename std::vector<CELL>::const_iterator it = m_cells.begin(); it != m_cells.end(); ++it)
 				m_lambda(*it,m_id);
+			m_cells.clear();
 			m_sync1.wait(); // wait every body has finished
 			m_sync2.wait(); // wait vectors has been refilled
 		}
@@ -584,6 +737,129 @@ void foreach_cell_tmpl(MAP& map, FUNC func, unsigned int nbth, bool needMarkers)
 	delete[] tempo;
 }
 
+
+//template <TraversalOptim OPT,unsigned int ORBIT, typename MAP, typename FUNC_E, typename FUNC_O>
+//void foreach_cell_EO_tmpl(MAP& map, FUNC_E funcEven, FUNC_O funcOdd, unsigned int nbPasses, unsigned int nbth, bool needMarkers=true)
+//{
+//	if (nbth==0)
+//		nbth = boost::thread::hardware_concurrency();
+
+//	std::vector< Cell<ORBIT> >* vd = new std::vector< Cell<ORBIT> >[nbth];
+
+//	for (unsigned int i = 0; i < nbth; ++i)
+//		vd[i].reserve(SIZE_BUFFER_THREAD);
+
+//	bool finished_even=false;
+//	bool finished_odd=false;
+//	// lauch threads
+//	if (needMarkers)
+//	{
+//		unsigned int nbth_prec = map.getNbThreadMarkers();
+//		if (nbth_prec < nbth+1)
+//			map.addThreadMarker(nbth+1-nbth_prec);
+//	}
+
+//	boost::thread** threads = new boost::thread*[2*nbth];
+//	ThreadFunction<ORBIT,FUNC_E>** tfse = new ThreadFunction<ORBIT,FUNC_E>*[nbth];
+//	ThreadFunction<ORBIT,FUNC_O>** tfso = new ThreadFunction<ORBIT,FUNC_O>*[nbth];
+
+//	boost::barrier sync1(nbth+1);
+//	boost::barrier sync2(nbth+1);
+//	boost::barrier sync3(nbth+1);
+//	boost::barrier sync4(nbth+1);
+
+//	for (unsigned int i = 0; i < nbth; ++i)
+//	{
+//		tfse[i] = new ThreadFunction<ORBIT,FUNC_E>(funcEven, vd[i],sync1,sync2, finished_even,1+i);
+//		threads[i] = new boost::thread( boost::ref( *(tfse[i]) ) );
+
+//		tfso[i] = new ThreadFunction<ORBIT,FUNC_O>(funcOdd, vd[i],sync3,sync4, finished_odd,1+i);
+//		threads[nbth+i] = new boost::thread( boost::ref( *(tfso[i]) ) );
+//	}
+
+//	// and continue to traverse the map
+//	std::vector< Cell<ORBIT> >* tempo = new std::vector< Cell<ORBIT> >[nbth];
+//	for (unsigned int i = 0; i < nbth; ++i)
+//		tempo[i].reserve(SIZE_BUFFER_THREAD);
+
+//	TraversorCell<MAP, ORBIT, OPT> trav(map);
+
+//	for (unsigned i=0; i<nbPasses; ++i)
+//	{
+//		Cell<ORBIT> cell = trav.begin();
+//		Cell<ORBIT> c_end = trav.end();
+//		while (cell.dart != c_end.dart)
+//		{
+//			for (unsigned int i = 0; i < nbth; ++i)
+//				tempo[i].clear();
+
+//			unsigned int nb = 0;
+//			while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
+//			{
+//				tempo[nb%nbth].push_back(cell);
+//				nb++;
+//				cell = trav.next();
+//			}
+//			sync1.wait();// wait for all thread to finish its vector
+//			for (unsigned int i = 0; i < nbth; ++i)
+//				vd[i].swap(tempo[i]);
+//			sync2.wait();// everybody refilled then go
+//		}
+//		sync1.wait();// wait for all thread to finish its vector
+//		sync2.wait(); // just wait for last barrier wait !
+
+//		cell = trav.begin();
+//		c_end = trav.end();
+//		while (cell.dart != c_end.dart)
+//		{
+//			for (unsigned int i = 0; i < nbth; ++i)
+//				tempo[i].clear();
+//			unsigned int nb = 0;
+
+//			while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
+//			{
+//				tempo[nb%nbth].push_back(cell);
+//				nb++;
+//				cell = trav.next();
+//			}
+//			sync3.wait();// wait for all thread to finish its vector
+//			for (unsigned int i = 0; i < nbth; ++i)
+//				vd[i].swap(tempo[i]);
+//			sync4.wait();// everybody refilled then go
+//		}
+//		sync3.wait();// wait for all thread to finish its vector
+//		sync4.wait(); // just wait for last barrier wait !
+//	}
+
+//	sync1.wait();// wait for all thread to finish its vector
+//	finished_even = true;// say finsih to everyone
+//	sync2.wait(); // just wait for last barrier wait !
+//	sync3.wait();// wait for all thread to finish its vector
+//	finished_odd = true;// say finsih to everyone
+//	sync4.wait(); // just wait for last barrier wait !
+
+//	//wait for all theads to be finished
+//	for (unsigned int i = 0; i < nbth; ++i)
+//	{
+//		threads[i]->join();
+//		delete threads[i];
+//		delete tfse[i];
+//		threads[i+nbth]->join();
+//		delete threads[i+nbth];
+//		delete tfso[i];
+//	}
+
+//	delete[] tfse;
+//	delete[] tfso;
+//	delete[] threads;
+//	delete[] vd;
+//	delete[] tempo;
+//}
+
+
+
+
+
 template <unsigned int ORBIT, typename MAP, typename FUNC>
 void foreach_cell(MAP& map, FUNC func, unsigned int nbth, bool needMarkers, TraversalOptim opt)
 {
@@ -602,11 +878,33 @@ void foreach_cell(MAP& map, FUNC func, unsigned int nbth, bool needMarkers, Trav
 	default:
 		foreach_cell_tmpl<AUTO,ORBIT,MAP,FUNC>(map,func,nbth,needMarkers);
 	break;
-
 	}
-
 }
 
+
+//template <unsigned int ORBIT, typename MAP, typename FUNC_E, typename FUNC_O>
+//void foreach_cell_EO(MAP& map, FUNC_E funcEven, FUNC_O funcOdd, unsigned int nbPasses, unsigned int nbth, bool needMarkers, TraversalOptim opt)
+//{
+//	switch(opt)
+//	{
+//	case FORCE_DART_MARKING:
+//		foreach_cell_EO_tmpl<FORCE_DART_MARKING,ORBIT,MAP,FUNC_E,FUNC_O>(map,funcEven,funcOdd,nbPasses,nbth,needMarkers);
+//	break;
+//	case FORCE_CELL_MARKING:
+//		foreach_cell_EO_tmpl<FORCE_CELL_MARKING,ORBIT,MAP,FUNC_E,FUNC_O>(map,funcEven,funcOdd,nbPasses,nbth,needMarkers);
+//	break;
+//	case FORCE_QUICK_TRAVERSAL:
+//		foreach_cell_EO_tmpl<FORCE_QUICK_TRAVERSAL,ORBIT,MAP,FUNC_E,FUNC_O>(map,funcEven,funcOdd,nbPasses,nbth,needMarkers);
+//	break;
+//	case AUTO:
+//	default:
+//		foreach_cell_EO_tmpl<AUTO,ORBIT,MAP,FUNC_E,FUNC_O>(map,funcEven,funcOdd,nbPasses,nbth,needMarkers);
+//	break;
+//	}
+//}
+
+
+
 }// namespace Parallel