Index: sm/trunk/src/c/Bamgx/BamgObjects.h
===================================================================
--- /issm/trunk/src/c/Bamgx/BamgObjects.h	(revision 3262)
+++ 	(revision )
@@ -1,304 +1,0 @@
-#ifndef _MESH2_H_
-#define _MESH2_H_
-
-#include "../objects/objects.h"
-#include "../shared/shared.h"
-#include "../include/macros.h"
-#include "../toolkits/toolkits.h"
-
-#include "meshtype.h"
-
-#include "objects/Metric.h"
-#include "objects/DoubleAndInt.h"
-#include "objects/Direction.h"
-#include "objects/Vertex.h"
-#include "objects/TriangleAdjacent.h"
-#include "objects/Edge.h"
-#include "objects/GeometricalVertex.h"
-#include "objects/GeometricalEdge.h"
-#include "objects/Curve.h"
-#include "objects/Triangle.h"
-#include "objects/ListofIntersectionTriangles.h"
-#include "objects/GeometricalSubDomain.h"
-#include "objects/SubDomain.h"
-#include "objects/VertexOnGeom.h"
-#include "objects/VertexOnVertex.h"
-#include "objects/VertexOnEdge.h"
-#include "objects/CrackedEdge.h"
-#include "objects/Triangles.h"
-#include "objects/Geometry.h"
-
-#include "shared/shared.h"
-
-namespace bamg {
-	
-	/*INLINE functions of CLASS VertexOnVertex{{{1*/
-	inline void VertexOnVertex::Set(const Triangles & Th ,long i,Triangles & ThNew) { 
-		*this = Th.VertexOnBThVertex[i];  
-		v = ThNew.vertices + Th.Number(v);
-
-	  }
-/*}}}1*/
-	/*INLINE functions of CLASS Triangles{{{1*/
-	inline  void  Triangles::ReMakeTriangleContainingTheVertex(){
-		register long i;
-		for ( i=0;i<nbv;i++){
-			vertices[i].vint=0;
-			vertices[i].t=0;
-		  }
-		for ( i=0;i<nbt;i++) triangles[i].SetTriangleContainingTheVertex();
-	  }
-
-	inline  void  Triangles::UnMarkUnSwapTriangle()
-	  {
-		register long i;
-		for ( i=0;i<nbt;i++) 
-		 for(int  j=0;j<3;j++)
-		  triangles[i].SetUnMarkUnSwap(j);
-	  }
-
-	inline  void   Triangles::SetVertexFieldOn(){
-		for (int i=0;i<nbv;i++) 
-		 vertices[i].onGeometry=0;
-		for (int j=0;j<NbVerticesOnGeomVertex;j++ ) 
-		 VerticesOnGeomVertex[j].SetOn();
-		for (int k=0;k<NbVerticesOnGeomEdge;k++ ) 
-		 VerticesOnGeomEdge[k].SetOn();
-	}	       
-	inline  void   Triangles::SetVertexFieldOnBTh(){
-		for (int i=0;i<nbv;i++) 
-		 vertices[i].onGeometry=0;
-		for (int j=0;j<NbVertexOnBThVertex;j++ ) 
-		 VertexOnBThVertex[j].SetOnBTh();
-		for (int k=0;k<NbVertexOnBThEdge;k++ ) 
-		 VertexOnBThEdge[k].SetOnBTh();
-
-	}
-	/*}}}1*/
-	/*INLINE functions of CLASS Triangle{{{1*/
-	inline Triangle* Triangle::Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const
-	  {
-		// return the other triangle of the quad if a quad or 0 if not a quat
-		Triangle * t =0;
-		if (link) {
-			int a=-1;
-			if (TriaAdjSharedEdge[0] & 16 ) a=0;
-			if (TriaAdjSharedEdge[1] & 16 ) a=1;
-			if (TriaAdjSharedEdge[2] & 16 ) a=2;
-			if (a>=0) {
-				t = TriaAdjTriangles[a];
-				//  if (t-this<0) return 0;
-				v2 = TriaVertices[VerticesOfTriangularEdge[a][0]];
-				v0 = TriaVertices[VerticesOfTriangularEdge[a][1]];
-				v1 = TriaVertices[OppositeEdge[a]];
-				v3 = t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
-			}
-		}
-		return t;
-	  }
-
-	inline   double   Triangle::QualityQuad(int a,int option) const
-	  { // first do the logique part 
-		double q;
-		if (!link || TriaAdjSharedEdge[a] &4)
-		 q=  -1;
-		else {
-			Triangle * t = TriaAdjTriangles[a];
-			if (t-this<0) q=  -1;// because we do 2 times 
-			else if (!t->link ) q=  -1;
-			else if (TriaAdjSharedEdge[0] & 16 || TriaAdjSharedEdge[1] & 16  || TriaAdjSharedEdge[2] & 16 || t->TriaAdjSharedEdge[0] & 16 || t->TriaAdjSharedEdge[1] & 16 || t->TriaAdjSharedEdge[2] & 16 )
-			 q= -1;
-			else if(option){ 
-				const Vertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
-				const Vertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
-				const Vertex & v1 = *TriaVertices[OppositeEdge[a]];
-				const Vertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
-				q =  QuadQuality(v0,v1,v2,v3); // do the float part
-			}
-			else q= 1;
-		}
-		return  q;
-	  }
-	inline void Triangle::Set(const Triangle & rec,const Triangles & Th ,Triangles & ThNew)
-	  { 
-		*this = rec;
-		if ( TriaVertices[0] ) TriaVertices[0] = ThNew.vertices +  Th.Number(TriaVertices[0]);
-		if ( TriaVertices[1] ) TriaVertices[1] = ThNew.vertices +  Th.Number(TriaVertices[1]);
-		if ( TriaVertices[2] ) TriaVertices[2] = ThNew.vertices +  Th.Number(TriaVertices[2]);
-		if(TriaAdjTriangles[0]) TriaAdjTriangles[0] =  ThNew.triangles + Th.Number(TriaAdjTriangles[0]);
-		if(TriaAdjTriangles[1]) TriaAdjTriangles[1] =  ThNew.triangles + Th.Number(TriaAdjTriangles[1]);
-		if(TriaAdjTriangles[2]) TriaAdjTriangles[2] =  ThNew.triangles + Th.Number(TriaAdjTriangles[2]);
-		if (link  >= Th.triangles && link  < Th.triangles + Th.nbt)
-		 link = ThNew.triangles + Th.Number(link);
-	  }
-	inline  Triangle::Triangle(Triangles *Th,long i,long j,long k) {
-		Vertex *v=Th->vertices;
-		long nbv = Th->nbv;
-		if (i<0 || j<0 || k<0){
-			throw ErrorException(__FUNCT__,exprintf("i<0 || j<0 || k<0"));
-		}
-		if (i>=nbv || j>=nbv || k>=nbv){
-			throw ErrorException(__FUNCT__,exprintf("i>=nbv || j>=nbv || k>=nbv"));
-		}
-		TriaVertices[0]=v+i;
-		TriaVertices[1]=v+j;
-		TriaVertices[2]=v+k;
-		TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
-		TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
-		det=0;
-	}
-	inline  Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
-		TriaVertices[0]=v0;
-		TriaVertices[1]=v1;
-		TriaVertices[2]=v2;
-		TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
-		TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
-		if (v0) det=0;
-		else {
-			det=-1;
-			link=NULL;};  
-	}
-	inline    double Triangle::qualite()
-	  {
-		return det < 0 ? -1 :  bamg::qualite(*TriaVertices[0],*TriaVertices[1],*TriaVertices[2]);
-	  }
-
-	/*}}}1*/
-	 /*INLINE functions of CLASS Edge{{{1*/
-	inline void Edge::Set(const Triangles & Th ,long i,Triangles & ThNew)
-	  { 
-		*this = Th.edges[i];
-		v[0] = ThNew.vertices + Th.Number(v[0]);    
-		v[1] = ThNew.vertices + Th.Number(v[1]);
-		if (onGeometry) 
-		 onGeometry =  ThNew.Gh.edges+Th.Gh.Number(onGeometry);
-		if (adj[0]) adj[0] =   ThNew.edges +   Th.Number(adj[0]);
-		if (adj[1]) adj[1] =   ThNew.edges +   Th.Number(adj[1]);
-
-	  }
-
-	/*}}}1*/
-	 /*INLINE functions of CLASS GeometricalEdge{{{1*/
-	inline void GeometricalEdge::Set(const GeometricalEdge & rec,const Geometry & Gh ,Geometry & GhNew)
-	  { 
-		*this = rec;
-		v[0] = GhNew.vertices + Gh.Number(v[0]);    
-		v[1] = GhNew.vertices + Gh.Number(v[1]); 
-		if (Adj[0]) Adj[0] =  GhNew.edges + Gh.Number(Adj[0]);     
-		if (Adj[1]) Adj[1] =  GhNew.edges + Gh.Number(Adj[1]);     
-	  }
-	/*}}}1*/
-	 /*INLINE functions of CLASS Curve{{{1*/
-	inline void Curve::Set(const Curve & rec,const Geometry & Gh ,Geometry & GhNew)
-	  {
-		*this = rec;
-		be = GhNew.edges + Gh.Number(be);    
-		ee = GhNew.edges + Gh.Number(ee); 
-		if(next) next= GhNew.curves + Gh.Number(next); 
-	  }
-	/*}}}1*/
-	 /*INLINE functions of CLASS SubDomain{{{1*/
-	inline void SubDomain::Set(const Triangles & Th ,long i,Triangles & ThNew)
-	  {
-		*this = Th.subdomains[i];
-		if ( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){
-			throw ErrorException(__FUNCT__,exprintf("head-Th.triangles<0 || head-Th.triangles>=Th.nbt"));
-		}
-		head = ThNew.triangles + Th.Number(head) ; 
-		if (edge-Th.edges<0 || edge-Th.edges>=Th.nbe);{
-			throw ErrorException(__FUNCT__,exprintf("edge-Th.edges<0 || edge-Th.edges>=Th.nbe"));
-		}
-		edge = ThNew.edges+ Th.Number(edge);
-	  }
-	/*}}}1*/
-	 /*INLINE functions of CLASS GeometricalSubDomain{{{1*/
-	inline void GeometricalSubDomain::Set(const GeometricalSubDomain & rec,const Geometry & Gh ,const Geometry & GhNew)
-	  {
-		*this = rec;
-		edge = Gh.Number(edge) + GhNew.edges;
-	  }
-	/*}}}1*/
-	/*INLINE functions of CLASS Vertex{{{1*/
-	long inline Vertex::Optim(int i,int koption){ 
-		long ret=0;
-		if ( t && (vint >= 0 ) && (vint <3) ){
-			ret = t->Optim(vint,koption);
-			if(!i){
-				t =0; // for no future optime 
-				vint= 0;
-			}
-		}
-		return ret;
-	}
-	inline void Vertex::Set(const Vertex & rec,const Triangles & ,Triangles & ){ 
-		*this  = rec;
-	}
-	/*}}}1*/
-	/*INLINE functions of CLASS VertexOnEdge{{{1*/
-	inline void VertexOnEdge::Set(const Triangles & Th ,long i,Triangles & ThNew)
-	  {
-		*this = Th.VertexOnBThEdge[i];  
-		v = ThNew.vertices + Th.Number(v);
-	  }
-	/*}}}1*/
-	/*INLINE functions of CLASS VertexOnGeom{{{1*/
-	inline void VertexOnGeom::Set(const VertexOnGeom & rec,const Triangles & Th ,Triangles & ThNew)
-	  {
-		*this = rec;  
-		mv = ThNew.vertices + Th.Number(mv);
-		if (gv)
-		 if (abscisse < 0 )
-		  gv = ThNew.Gh.vertices + Th.Gh.Number(gv);
-		 else
-		  ge = ThNew.Gh.edges + Th.Gh.Number(ge);
-
-	  }
-	/*}}}1*/
-	 /*INLINE functions of CLASS TriangleAdjacent{{{1*/
-	inline  void  TriangleAdjacent::SetAdj2(const TriangleAdjacent & ta, int l  ){
-		//set Adjacent Triangle of a triangle
-		if(t) {
-			t->TriaAdjTriangles[a]=ta.t;
-			t->TriaAdjSharedEdge[a]=ta.a|l;
-		}
-		if(ta.t) {
-			ta.t->TriaAdjTriangles[ta.a] = t ;
-			ta.t->TriaAdjSharedEdge[ta.a] = a| l ;
-		}
-	}
-	inline int  TriangleAdjacent::Locked() const
-	  { return t->TriaAdjSharedEdge[a] &4;}
-	inline int  TriangleAdjacent::Cracked() const
-	  { return t->TriaAdjSharedEdge[a] &32;}
-	inline int  TriangleAdjacent::GetAllFlag_UnSwap() const
-	  { return t->TriaAdjSharedEdge[a] & 1012;} // take all flag except MarkUnSwap
-	inline int  TriangleAdjacent::MarkUnSwap() const
-	  { return t->TriaAdjSharedEdge[a] &8;}
-	inline void  TriangleAdjacent::SetLock(){ t->SetLocked(a);}
-	inline void  TriangleAdjacent::SetCracked() { t->SetCracked(a);}
-	inline  TriangleAdjacent TriangleAdjacent::Adj() const
-	  { return  t->Adj(a);}
-	inline Vertex  * TriangleAdjacent::EdgeVertex(const int & i) const
-	  {return t->TriaVertices[VerticesOfTriangularEdge[a][i]]; }
-	inline Vertex  * TriangleAdjacent::OppositeVertex() const
-	  {return t->TriaVertices[bamg::OppositeVertex[a]]; }
-	inline Icoor2 &  TriangleAdjacent::det() const
-	  { return t->det;}
-	int inline TriangleAdjacent::swap()
-	  { return  t->swap(a);}
-	/*}}}1*/
-
-	/*Other prototypes IN TRIANGLES.CPP (TO BE REORGANIZED){{{1*/
-	TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
-	TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
-	void  swap(Triangle *t1,short a1,
-				Triangle *t2,short a2,
-				Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);
-	int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,
-				TriangleAdjacent & tt1,Icoor2 & dets1,
-				Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
-	int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret) ;
-	/*}}}1*/
-
-}
-#endif
Index: /issm/trunk/src/c/Bamgx/Bamgx.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/Bamgx.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/Bamgx.cpp	(revision 3263)
@@ -17,6 +17,5 @@
 #include <stdio.h>
 #include <string.h>
-#include "BamgObjects.h"
-#include "objects/QuadTree.h"
+#include "objects/BamgObjects.h"
 
 using namespace bamg;
Index: /issm/trunk/src/c/Bamgx/objects/BamgObjects.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/BamgObjects.h	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/BamgObjects.h	(revision 3263)
@@ -0,0 +1,25 @@
+#ifndef _BAMGOBEJECTS_H_
+#define _BAMGOBEJECTS_H_
+
+/*Bamg objects (Must be compiled in this order!!*/
+#include "./Metric.h"
+#include "./DoubleAndInt.h"
+#include "./Direction.h"
+#include "./Vertex.h"
+#include "./TriangleAdjacent.h"
+#include "./Edge.h"
+#include "./GeometricalVertex.h"
+#include "./GeometricalEdge.h"
+#include "./Curve.h"
+#include "./Triangle.h"
+#include "./ListofIntersectionTriangles.h"
+#include "./GeometricalSubDomain.h"
+#include "./SubDomain.h"
+#include "./VertexOnGeom.h"
+#include "./VertexOnVertex.h"
+#include "./VertexOnEdge.h"
+#include "./CrackedEdge.h"
+#include "./Triangles.h"
+#include "./Geometry.h"
+
+#endif
Index: /issm/trunk/src/c/Bamgx/objects/CrackedEdge.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/CrackedEdge.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/CrackedEdge.cpp	(revision 3263)
@@ -0,0 +1,34 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "CrackedEdge.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "CrackedEdge"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION CrackedEdge::Crack {{{1*/
+	void CrackedEdge::Crack() {
+		a.Crack();
+		b.Crack();
+	}
+	/*}}}*/
+	/*FUNCTION CrackedEdge::UnCrack {{{1*/
+	void CrackedEdge::UnCrack() {
+		a.UnCrack();
+		b.UnCrack();
+	}
+	/*}}}*/
+	/*FUNCTION {{{1*/
+	void CrackedEdge::Set(){
+		a.Set();
+		b.Set();}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h	(revision 3263)
@@ -12,6 +12,4 @@
 #include "Edge.h"
 #include "Triangle.h"
-#include "../shared/TheVertex.h"
-#include "../shared/FindTriangleAdjacent.h"
 
 namespace bamg {
@@ -37,33 +35,7 @@
 
 			//Methods
-			void Crack(){ 
-				Triangle & T(*t); 
-				int i0=VerticesOfTriangularEdge[i][0];
-				int i1=VerticesOfTriangularEdge[i][0];
-				if (!New[0] && !New[1]){
-					throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
-				}
-				T(i0) = New[0];
-				T(i1) = New[1];
-			}    
-			void UnCrack(){ 
-				Triangle & T(*t); 
-				int i0=VerticesOfTriangularEdge[i][0];
-				int i1=VerticesOfTriangularEdge[i][0];
-				if (!New[0] && !New[1]){
-					throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
-				}
-				T(i0) = TheVertex(T(i0));
-				T(i1) = TheVertex(T(i1));
-			} 
-			void Set() {
-				TriangleAdjacent ta ( FindTriangleAdjacent(*edge));
-				t = ta;
-				i = ta;
-
-				New[0] = ta.EdgeVertex(0);
-				New[1] = ta.EdgeVertex(1);
-				// warning the ref 
-			}    
+			void Crack();
+			void UnCrack();
+			void Set();
 		};
 
@@ -77,8 +49,69 @@
 
 			//Methods
-			void Crack() { a.Crack(); b.Crack();}
-			void UnCrack() { a.UnCrack(); b.UnCrack();}
-			void Set() { a.Set(), b.Set();}
+			void Crack();
+			void UnCrack();
+			void Set();
 	};
+
+	/*Intermediary*/
+	inline TriangleAdjacent FindTriangleAdjacent(Edge &E){
+		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
+
+		Vertex * a = E.v[0];
+		Vertex * b = E.v[1];
+
+		Triangle * t = a->t;
+		int i = a->vint;
+		TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
+		if (!t || i<0 || i>=3){
+			throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
+		}
+		if ( a!=(*t)(i)){
+			throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
+		}
+		int k=0;
+		do { // turn around vertex in direct sens (trigo)
+			k++;
+			if (k>=20000){
+				throw ErrorException(__FUNCT__,exprintf("k>=20000"));
+			}
+			//  in no crack => ta.EdgeVertex(1) == a otherwise ??? 
+			if (ta.EdgeVertex(1) ==  a && ta.EdgeVertex(0) ==  b) return ta; // find 
+			ta = ta.Adj();
+			if (ta.EdgeVertex(0) ==  a && ta.EdgeVertex(1) ==  b) return ta; // find 
+			--ta;
+		} while (t != (Triangle *)ta);
+		throw ErrorException(__FUNCT__,exprintf("FindTriangleAdjacent: triangle not found"));
+		return TriangleAdjacent(0,0);//for compiler
+	}
+	inline Vertex* TheVertex(Vertex * a){// for remove crak in mesh 
+		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
+
+		// give a unique vertex with smallest number
+		// in case on crack in mesh 
+		Vertex * r(a), *rr;
+		Triangle * t = a->t;
+		int i = a->vint;
+		TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
+		if (!t || i<0 || i>=3){
+			throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
+		}
+		if ( a!=(*t)(i)){
+			throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
+		}
+		int k=0;
+		do { // turn around vertex in direct sens (trigo)
+			k++;
+			if (k>=20000){
+				throw ErrorException(__FUNCT__,exprintf("k>=20000"));
+			}
+			//  in no crack => ta.EdgeVertex(1) == a
+			if ((rr=ta.EdgeVertex(0)) < r) r = rr;
+			ta = ta.Adj();
+			if ((rr=ta.EdgeVertex(1)) < r) r =rr;
+			--ta;
+		} while (t != (Triangle*) ta);  
+		return r;
+	}
 
 }
Index: /issm/trunk/src/c/Bamgx/objects/CrackedTriangle.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/CrackedTriangle.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/CrackedTriangle.cpp	(revision 3263)
@@ -0,0 +1,52 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "CrackedEdge.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "CrackedTriangle"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION CrackedEdge::CrackedTriangle::Crack{{{1*/
+	void CrackedEdge::CrackedTriangle::Crack(){ 
+		Triangle & T(*t); 
+		int i0=VerticesOfTriangularEdge[i][0];
+		int i1=VerticesOfTriangularEdge[i][0];
+		if (!New[0] && !New[1]){
+			throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
+		}
+		T(i0) = New[0];
+		T(i1) = New[1];
+	} 
+	/*}}}*/
+	/*FUNCTION CrackedEdge::CrackedTriangle::UnCrack {{{1*/
+	void CrackedEdge::CrackedTriangle::UnCrack(){ 
+		Triangle & T(*t); 
+		int i0=VerticesOfTriangularEdge[i][0];
+		int i1=VerticesOfTriangularEdge[i][0];
+		if (!New[0] && !New[1]){
+			throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
+		}
+		T(i0) = TheVertex(T(i0));
+		T(i1) = TheVertex(T(i1));
+	} 
+	/*}}}*/
+	/*FUNCTION CrackedEdge::CrackedTriangle::Set {{{1*/
+	void CrackedEdge::CrackedTriangle::Set(){
+		TriangleAdjacent ta( FindTriangleAdjacent(*edge));
+		t = ta;
+		i = ta;
+
+		New[0] = ta.EdgeVertex(0);
+		New[1] = ta.EdgeVertex(1);
+		// warning the ref 
+	} 
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/Curve.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Curve.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/Curve.cpp	(revision 3263)
@@ -0,0 +1,26 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "Curve.h"
+#include "Geometry.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "Curve"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION Curve::Set {{{1*/
+	void Curve::Set(const Curve & rec,const Geometry & Gh ,Geometry & GhNew){
+		*this = rec;
+		be = GhNew.edges + Gh.Number(be);    
+		ee = GhNew.edges + Gh.Number(ee); 
+		if(next) next= GhNew.curves + Gh.Number(next); 
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/Curve.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Curve.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Curve.h	(revision 3263)
@@ -25,7 +25,5 @@
 			Curve() : be(0),ee(0),kb(0),ke(0),next(0),master(true) {} 
 			void Reverse() { Exchange(be,ee); Exchange(kb,ke);} //  revese the sens of the curse 
-
-			//Inline methods
-			inline void Set(const Curve & rec,const Geometry & Th ,Geometry & ThNew);
+			void Set(const Curve & rec,const Geometry & Th ,Geometry & ThNew);
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/Direction.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Direction.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/Direction.cpp	(revision 3263)
@@ -0,0 +1,34 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "Direction.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "Direction"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+	/*FUNCTION Direction(Icoor1 i,Icoor1 j) {{{1*/
+	Direction::Direction(Icoor1 i,Icoor1 j) {
+		Icoor2 n2 = 2*(Abs(i)+Abs(j));  
+		Icoor2 r  = MaxICoor* (Icoor2) i;
+		Icoor1 r1 = (Icoor1) (2*(r/ n2)); // odd number 
+		dir = (j>0) ? r1 : r1+1;          // odd-> j>0 even-> j<0
+	}/*}}}*/
+
+	/*Methods*/
+	/*FUNCTION Direction::sens{{{1*/
+	int Direction::sens(Icoor1 i,Icoor1 j) {
+		int r =1; 
+		if (dir!= MaxICoor) {
+			Icoor2 x(dir/2),y1(MaxICoor/2-Abs(x)),y(dir%2?-y1:y1);
+			r = (x*i + y*j) >=0;
+		}
+		return r;
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/Direction.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Direction.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Direction.h	(revision 3263)
@@ -13,18 +13,6 @@
 			//Methods
 			Direction(): dir(MaxICoor){}; //  no direction set
-			Direction(Icoor1 i,Icoor1 j) {
-				Icoor2 n2 = 2*(Abs(i)+Abs(j));  
-				Icoor2 r  = MaxICoor* (Icoor2) i;
-				Icoor1 r1 = (Icoor1) (2*(r/ n2)); // odd number 
-				dir = (j>0) ? r1 : r1+1;          // odd-> j>0 even-> j<0
-			}
-			int sens(Icoor1 i,Icoor1 j) {
-				int r =1; 
-				if (dir!= MaxICoor) {
-					Icoor2 x(dir/2),y1(MaxICoor/2-Abs(x)),y(dir%2?-y1:y1);
-					r = (x*i + y*j) >=0;
-				}
-				return r;
-			}
+			Direction(Icoor1 i,Icoor1 j);
+			int sens(Icoor1 i,Icoor1 j);
 	};
 }
Index: /issm/trunk/src/c/Bamgx/objects/Edge.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Edge.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/Edge.cpp	(revision 3263)
@@ -0,0 +1,30 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "Edge.h"
+#include "Triangles.h"
+#include "Geometry.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "Edge"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION Edge::Set {{{1*/
+	void Edge::Set(const Triangles & Th ,long i,Triangles & ThNew){ 
+		*this = Th.edges[i];
+		v[0] = ThNew.vertices + Th.Number(v[0]);    
+		v[1] = ThNew.vertices + Th.Number(v[1]);
+		if (onGeometry) 
+		 onGeometry =  ThNew.Gh.edges+Th.Gh.Number(onGeometry);
+		if (adj[0]) adj[0] =   ThNew.edges +   Th.Number(adj[0]);
+		if (adj[1]) adj[1] =   ThNew.edges +   Th.Number(adj[1]);
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/Edge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Edge.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Edge.h	(revision 3263)
@@ -45,7 +45,5 @@
 				return adj[0]==&e ? 0 : 1;
 			}
-
-			//Inline methods
-			inline void Set(const Triangles &,long,Triangles &);
+			void Set(const Triangles &,long,Triangles &);
 
 	};
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.cpp	(revision 3263)
@@ -5,4 +5,5 @@
 
 #include "GeometricalEdge.h"
+#include "Geometry.h"
 
 #undef __FUNCT__ 
@@ -133,4 +134,13 @@
 	  }
 	/*}}}1*/
+	/*FUNCTION GeometricalEdge::Set {{{1*/
+	void GeometricalEdge::Set(const GeometricalEdge & rec,const Geometry & Gh ,Geometry & GhNew){ 
+		*this = rec;
+		v[0] = GhNew.vertices + Gh.Number(v[0]);    
+		v[1] = GhNew.vertices + Gh.Number(v[1]); 
+		if (Adj[0]) Adj[0] =  GhNew.edges + Gh.Number(Adj[0]);     
+		if (Adj[1]) Adj[1] =  GhNew.edges + Gh.Number(Adj[1]);     
+	}
+	/*}}}*/
 
 }
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalEdge.h	(revision 3263)
@@ -55,7 +55,5 @@
 			void SetRequired() { flag |= 64;}
 			void SetReverseEqui() {flag |= 128;}
-
-			//Inline methods
-			inline void Set(const GeometricalEdge & rec,const Geometry & Th ,Geometry & ThNew);
+			void Set(const GeometricalEdge & rec,const Geometry & Th ,Geometry & ThNew);
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.cpp	(revision 3263)
@@ -0,0 +1,23 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "GeometricalSubDomain.h"
+#include "Geometry.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "GeometricalSubDomain"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION GeometricalSubDomain::Set {{{1*/
+	void GeometricalSubDomain::Set(const GeometricalSubDomain & rec,const Geometry & Gh ,const Geometry & GhNew){
+		*this = rec;
+		edge = Gh.Number(edge) + GhNew.edges;
+	}/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.h	(revision 3263)
@@ -21,6 +21,6 @@
 			long ref;
 
-			//Inline methods
-			inline void Set(const GeometricalSubDomain &,const Geometry & ,const Geometry &);
+			//Methods
+			void Set(const GeometricalSubDomain &,const Geometry & ,const Geometry &);
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.cpp	(revision 3263)
@@ -0,0 +1,56 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+#include <assert.h>
+
+#include "GeometricalVertex.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "GeometricalVertex"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+	//See header file
+
+	/*Methods*/
+	/*FUNCTION GeometricalVertex::Corner {{{1*/
+	int  GeometricalVertex::Corner() const {
+		return cas & 4;
+	}
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::Required {{{1*/
+	int  GeometricalVertex::Required()const {
+		// a corner is required
+		return cas & 6;
+	}
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::IsThe {{{1*/
+	int  GeometricalVertex::IsThe() const {
+		return link == this;
+	}  
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::SetCorner {{{1*/
+	void GeometricalVertex::SetCorner(){
+		cas |= 4;
+	}
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::SetRequired {{{1*/
+	void GeometricalVertex::SetRequired(){
+		cas |= 2;
+	}
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::Set {{{1*/
+	void GeometricalVertex::Set(){
+		cas=0;
+	}
+	/*}}}*/
+	/*FUNCTION GeometricalVertex::The {{{1*/
+	GeometricalVertex* GeometricalVertex::The(){
+		// return a unique vertex
+		assert(link);
+		return link;
+	}/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h	(revision 3263)
@@ -8,4 +8,5 @@
 
 #include "../meshtype.h"
+#include "Vertex.h"
 
 namespace bamg {
@@ -22,20 +23,19 @@
 			GeometricalVertex* link; //  link all the same GeometricalVertex circular (Crack) 
 
+			//Constructors
+			GeometricalVertex() :cas(0), link(this) {};
+
 			//Methods
-			int  Corner() const {return cas&4;}
-			int  Required()const {return cas&6;}// a corner is required
-			int  IsThe() const { return link == this;}  
-			void SetCorner(){ cas |= 4;}
-			void SetRequired(){ cas |= 2;}
-			void Set(){cas=0;}
-			GeometricalVertex() :cas(0), link(this) {};
-			GeometricalVertex* The() {
-				if (!link){ throw ErrorException(__FUNCT__,exprintf("!link"));}
-				return link;
-			}// return a unique vertex
+			int  Corner() const;
+			int  Required()const;
+			int  IsThe() const;
+			void SetCorner();
+			void SetRequired();
+			void Set();
+			GeometricalVertex* The();
 
 			//Inline methods
-			inline void Set(const GeometricalVertex & rec,const Geometry & ,const Geometry & ){ 
-				*this  = rec;
+			inline void Set(const GeometricalVertex & rec,const Geometry & ,const Geometry & ){
+				*this=rec;
 			}
 	};
Index: /issm/trunk/src/c/Bamgx/objects/Geometry.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Geometry.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Geometry.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 #include <ctime>
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 
 #undef __FUNCT__ 
Index: /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 #include <ctime>
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 #include "../shared/shared.h"
 
Index: /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 
 //#include "QuadTree.h"
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 
 #undef __FUNCT__ 
@@ -11,11 +11,8 @@
 namespace bamg {
 
-	//INTER_SEG(a,b,x,y) returns 1 if [x y] is included in [a b]
+	/*MACROS {{{1*/
 #define INTER_SEG(a,b,x,y) (((y) > (a)) && ((x) <(b)))
-	//ABS(i) retruns |i|
 #define ABS(i) ((i)<0 ?-(i) :(i))
-	//MAX1(i,j) returns max(i,j)
 #define MAX1(i,j) ((i)>(j) ?(i) :(j))
-	//NORM(i1,j1,i2,j2) returns max(|i1-j1|,|i2-j2|)
 #define NORM(i1,j1,i2,j2) MAX1(ABS((i1)-(j1)),ABS((i2)-(j2)))
 	//IJ(i,j,l) returns the box number of i and j with respect to l
@@ -29,6 +26,6 @@
 	//J_IJ(k,l) returns l if second bit of k is 1, else 0
 #define J_IJ(k,l)  ((k&2) ? l:0)
-
-	/*What is a QuadTree?
+	/*}}}*/
+	/*DOCUMENTATION What is a QuadTree? {{{1
 	 * A Quadtree is a very simple way to group the vertices according
 	 * to their location. A square that holds all the points of the mesh
@@ -76,5 +73,5 @@
 	 * Using the binaries is therefor very easy to locate a vertex in a box:
 	 * we just need to look at the bits from the left to the right (See ::Add)
-	 */
+	 }}}1*/
 
 	/*Constructors/Destructors*/
Index: /issm/trunk/src/c/Bamgx/objects/SetOfE4.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/SetOfE4.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/SetOfE4.cpp	(revision 3263)
@@ -1,4 +1,4 @@
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 
 #undef __FUNCT__ 
Index: /issm/trunk/src/c/Bamgx/objects/SubDomain.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/SubDomain.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/SubDomain.cpp	(revision 3263)
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "SubDomain.h"
+#include "Triangles.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "SubDomains"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION SubDomain::Set {{{1*/
+	void SubDomain::Set(const Triangles & Th ,long i,Triangles & ThNew){
+		*this = Th.subdomains[i];
+		if ( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){
+			throw ErrorException(__FUNCT__,exprintf("head-Th.triangles<0 || head-Th.triangles>=Th.nbt"));
+		}
+		head = ThNew.triangles + Th.Number(head) ; 
+		if (edge-Th.edges<0 || edge-Th.edges>=Th.nbe);{
+			throw ErrorException(__FUNCT__,exprintf("edge-Th.edges<0 || edge-Th.edges>=Th.nbe"));
+		}
+		edge = ThNew.edges+ Th.Number(edge);
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/SubDomain.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/SubDomain.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/SubDomain.h	(revision 3263)
@@ -23,6 +23,6 @@
 			Edge* edge; // to  geometrical 	
 
-			//Inline methods
-			inline void Set(const Triangles &,long,Triangles &);
+			//Methods
+			void Set(const Triangles &,long,Triangles &);
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/Triangle.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangle.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Triangle.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 #include <ctime>
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 #include "../shared/shared.h"
 
@@ -12,5 +12,69 @@
 namespace bamg {
 
+	/*Constructors/Destructors*/
+	/*FUNCTION Triangle(Triangles *Th,long i,long j,long k) {{{1*/
+	Triangle::Triangle(Triangles *Th,long i,long j,long k) {
+		Vertex *v=Th->vertices;
+		long nbv = Th->nbv;
+		if (i<0 || j<0 || k<0){
+			throw ErrorException(__FUNCT__,exprintf("i<0 || j<0 || k<0"));
+		}
+		if (i>=nbv || j>=nbv || k>=nbv){
+			throw ErrorException(__FUNCT__,exprintf("i>=nbv || j>=nbv || k>=nbv"));
+		}
+		TriaVertices[0]=v+i;
+		TriaVertices[1]=v+j;
+		TriaVertices[2]=v+k;
+		TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
+		TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
+		det=0;
+	}
+	/*}}}*/
+	/*FUNCTION Triangle(Vertex *v0,Vertex *v1,Vertex *v2) {{{1*/
+	Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
+		TriaVertices[0]=v0;
+		TriaVertices[1]=v1;
+		TriaVertices[2]=v2;
+		TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
+		TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
+		if (v0) det=0;
+		else {
+			det=-1;
+			link=NULL;};  
+	}
+	/*}}}*/
+
 	/*Methods*/
+	/*FUNCTION Triangle::Echo {{{1*/
+	void Triangle::Echo(void){
+
+		int i;
+
+		printf("Triangle:\n");
+		printf("   TriaVertices pointer towards three vertices\n");
+		printf("      TriaVertices[0] TriaVertices[1] TriaVertices[2] = %p %p %p\n",TriaVertices[0],TriaVertices[1],TriaVertices[2]);
+		printf("   TriaAdjTriangles pointer towards three adjacent triangles\n");
+		printf("      TriaAdjTriangles[0] TriaAdjTriangles[1] TriaAdjTriangles[2] = %p %p %p\n",TriaAdjTriangles[0],TriaAdjTriangles[1],TriaAdjTriangles[2]);
+		printf("   det (integer triangle determinant) = %i\n",det);
+		if (link){
+			printf("   link (pointer toward duplicate triangle)= %p\n",link);
+		}
+		else{
+			printf("   color = %i\n",color);
+		}
+
+		printf("\nThree vertices:\n");
+		for(i=0;i<3;i++){
+			if (TriaVertices[i]){
+				TriaVertices[i]->Echo();
+			}
+			else{
+				printf("   vertex %i does not exist\n",i+1);
+			}
+		}
+
+		return;
+	}
+	/*}}}*/
 	/*FUNCTION Triangle::FindBoundaryEdge{{{1*/
 	TriangleAdjacent Triangle::FindBoundaryEdge(int i) const{
@@ -60,35 +124,4 @@
 	}
 	/*}}}1*/
-	/*FUNCTION Triangle::Echo {{{1*/
-	void Triangle::Echo(void){
-
-		int i;
-
-		printf("Triangle:\n");
-		printf("   TriaVertices pointer towards three vertices\n");
-		printf("      TriaVertices[0] TriaVertices[1] TriaVertices[2] = %p %p %p\n",TriaVertices[0],TriaVertices[1],TriaVertices[2]);
-		printf("   TriaAdjTriangles pointer towards three adjacent triangles\n");
-		printf("      TriaAdjTriangles[0] TriaAdjTriangles[1] TriaAdjTriangles[2] = %p %p %p\n",TriaAdjTriangles[0],TriaAdjTriangles[1],TriaAdjTriangles[2]);
-		printf("   det (integer triangle determinant) = %i\n",det);
-		if (link){
-			printf("   link (pointer toward duplicate triangle)= %p\n",link);
-		}
-		else{
-			printf("   color = %i\n",color);
-		}
-
-		printf("\nThree vertices:\n");
-		for(i=0;i<3;i++){
-			if (TriaVertices[i]){
-				TriaVertices[i]->Echo();
-			}
-			else{
-				printf("   vertex %i does not exist\n",i+1);
-			}
-		}
-
-		return;
-	}
-	/*}}}*/
 	/*FUNCTION Triangle::Optim{{{1*/
 	long  Triangle::Optim(short i,int koption) {
@@ -124,4 +157,61 @@
 	}
 	/*}}}1*/
+	/*FUNCTION Triangle::Quadrangle {{{1*/
+	Triangle* Triangle::Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const{
+		// return the other triangle of the quad if a quad or 0 if not a quat
+		Triangle * t =0;
+		if (link) {
+			int a=-1;
+			if (TriaAdjSharedEdge[0] & 16 ) a=0;
+			if (TriaAdjSharedEdge[1] & 16 ) a=1;
+			if (TriaAdjSharedEdge[2] & 16 ) a=2;
+			if (a>=0) {
+				t = TriaAdjTriangles[a];
+				//  if (t-this<0) return 0;
+				v2 = TriaVertices[VerticesOfTriangularEdge[a][0]];
+				v0 = TriaVertices[VerticesOfTriangularEdge[a][1]];
+				v1 = TriaVertices[OppositeEdge[a]];
+				v3 = t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
+			}
+		}
+		return t;
+	}
+	/*}}}*/
+	/*FUNCTION Triangle::QualityQuad {{{1*/
+	double   Triangle::QualityQuad(int a,int option) const{
+		double q;
+		if (!link || TriaAdjSharedEdge[a] &4)
+		 q=  -1;
+		else {
+			Triangle * t = TriaAdjTriangles[a];
+			if (t-this<0) q=  -1;// because we do 2 times 
+			else if (!t->link ) q=  -1;
+			else if (TriaAdjSharedEdge[0] & 16 || TriaAdjSharedEdge[1] & 16  || TriaAdjSharedEdge[2] & 16 || t->TriaAdjSharedEdge[0] & 16 || t->TriaAdjSharedEdge[1] & 16 || t->TriaAdjSharedEdge[2] & 16 )
+			 q= -1;
+			else if(option){ 
+				const Vertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
+				const Vertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
+				const Vertex & v1 = *TriaVertices[OppositeEdge[a]];
+				const Vertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
+				q =  QuadQuality(v0,v1,v2,v3); // do the float part
+			}
+			else q= 1;
+		}
+		return  q;
+	}
+	/*}}}*/
+	/*FUNCTION Triangle::Set {{{1*/
+	void Triangle::Set(const Triangle & rec,const Triangles & Th ,Triangles & ThNew){ 
+		*this = rec;
+		if ( TriaVertices[0] ) TriaVertices[0] = ThNew.vertices +  Th.Number(TriaVertices[0]);
+		if ( TriaVertices[1] ) TriaVertices[1] = ThNew.vertices +  Th.Number(TriaVertices[1]);
+		if ( TriaVertices[2] ) TriaVertices[2] = ThNew.vertices +  Th.Number(TriaVertices[2]);
+		if(TriaAdjTriangles[0]) TriaAdjTriangles[0] =  ThNew.triangles + Th.Number(TriaAdjTriangles[0]);
+		if(TriaAdjTriangles[1]) TriaAdjTriangles[1] =  ThNew.triangles + Th.Number(TriaAdjTriangles[1]);
+		if(TriaAdjTriangles[2]) TriaAdjTriangles[2] =  ThNew.triangles + Th.Number(TriaAdjTriangles[2]);
+		if (link  >= Th.triangles && link  < Th.triangles + Th.nbt)
+		 link = ThNew.triangles + Th.Number(link);
+	}
+	/*}}}*/
 	/*FUNCTION Triangle::swap{{{1*/
 	int Triangle::swap(short a,int koption){
@@ -226,5 +316,5 @@
 						 OnSwap = som < 2;
 						 break;
-						}
+					 }
 
 				} // OnSwap 
Index: /issm/trunk/src/c/Bamgx/objects/Triangle.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangle.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Triangle.h	(revision 3263)
@@ -126,7 +126,7 @@
 
 			//Inline methods
-			inline double qualite() ;
-			inline void  Set(const Triangle &,const Triangles &,Triangles &);
-			inline int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
+			double qualite() ;
+			void  Set(const Triangle &,const Triangles &,Triangles &);
+			int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
 
 	};
Index: /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp	(revision 3263)
@@ -0,0 +1,89 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "TriangleAdjacent.h"
+#include "Triangles.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "TriangleAdjacent"
+
+namespace bamg {
+
+
+	/*Constructors/Destructors*/
+	//See header file
+
+	/*Methods*/
+	/*FUNCTION TriangleAdjacent::Locked {{{1*/
+	int  TriangleAdjacent::Locked() const {
+		return t->TriaAdjSharedEdge[a] & 4;
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::MarkUnSwap {{{1*/
+	int  TriangleAdjacent::MarkUnSwap() const {
+		return t->TriaAdjSharedEdge[a] & 8;
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::Cracked {{{1*/
+	int  TriangleAdjacent::Cracked() const {
+		return t->TriaAdjSharedEdge[a] & 32;
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::GetAllFlag_UnSwap {{{1*/
+	int  TriangleAdjacent::GetAllFlag_UnSwap() const {
+		// take all flag except MarkUnSwap
+		return t->TriaAdjSharedEdge[a] & 1012;
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::SetLock {{{1*/
+	void TriangleAdjacent::SetLock(){
+		t->SetLocked(a);
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::SetCracked {{{1*/
+	void TriangleAdjacent::SetCracked() {
+		t->SetCracked(a);
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::Adj {{{1*/
+	TriangleAdjacent TriangleAdjacent::Adj() const {
+		return  t->Adj(a);
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/
+	Vertex* TriangleAdjacent::EdgeVertex(const int & i) const {
+		return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/
+	Vertex* TriangleAdjacent::OppositeVertex() const {
+		return t->TriaVertices[bamg::OppositeVertex[a]]; 
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::det {{{1*/
+	Icoor2 & TriangleAdjacent::det() const {
+		return t->det;
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::swap {{{1*/
+	int TriangleAdjacent::swap(){
+		return  t->swap(a);
+	}
+	/*}}}*/
+	/*FUNCTION TriangleAdjacent::SetAdj2 {{{1*/
+	void TriangleAdjacent::SetAdj2(const TriangleAdjacent & ta, int l  ){
+		//set Adjacent Triangle of a triangle
+		if(t) {
+			t->TriaAdjTriangles[a]=ta.t;
+			t->TriaAdjSharedEdge[a]=ta.a|l;
+		}
+		if(ta.t) {
+			ta.t->TriaAdjTriangles[ta.a] = t ;
+			ta.t->TriaAdjSharedEdge[ta.a] = a| l ;
+		}
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h	(revision 3263)
@@ -33,19 +33,18 @@
 
 			//Methods
-			int swap();
 
-			//Inline methods
-			inline TriangleAdjacent  Adj() const ;
-			inline void SetAdj2(const TriangleAdjacent& , int =0);
-			inline Vertex *  EdgeVertex(const int &) const ;
-			inline Vertex *  OppositeVertex() const ;
-			inline Icoor2 & det() const;
-			inline int Locked() const  ;
-			inline int GetAllFlag_UnSwap() const ;
-			inline void SetLock();
-			inline int MarkUnSwap()  const;
-			inline void SetMarkUnSwap();
-			inline void SetCracked();
-			inline int Cracked() const ;
+			//Methods
+			int  Locked() const;
+			int  MarkUnSwap() const;
+			int  Cracked() const;
+			int  GetAllFlag_UnSwap() const;
+			void SetLock();
+			void SetCracked();
+			void SetAdj2(const TriangleAdjacent &ta, int l=0);
+			int  swap();
+			TriangleAdjacent Adj() const;
+			Vertex* EdgeVertex(const int & i) const;
+			Vertex* OppositeVertex() const;
+			Icoor2& det() const;
 	};
 }
Index: /issm/trunk/src/c/Bamgx/objects/Triangles.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 #include <ctime>
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 #include "../shared/shared.h"
 #include "QuadTree.h"
@@ -5421,49 +5421,4 @@
 
 	/*Intermediary*/
-	/*FUNCTION swap{{{1*/
-	void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){ 
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
-		// --------------------------------------------------------------
-		// short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
-		//                               
-		//               sb                     sb    
-		//             / | \                   /   \                      !
-		//         as1/  |  \                 /a2   \                     !
-		//           /   |   \               /    t2 \                    !
-		//       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
-		//          \  a1|a2  /             \   as1   /  
-		//           \   |   /               \ t1    /   
-		//            \  |  / as2             \   a1/    
-		//             \ | /                   \   /     
-		//              sa                       sa   
-		//  -------------------------------------------------------------
-		int as1 = NextEdge[a1];
-		int as2 = NextEdge[a2];
-		int ap1 = PreviousEdge[a1];
-		int ap2 = PreviousEdge[a2];
-		(*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
-		(*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
-		// mise a jour des 2 adjacences externes 
-		TriangleAdjacent taas1 = t1->Adj(as1),
-							  taas2 = t2->Adj(as2),
-							  tas1(t1,as1), tas2(t2,as2),
-							  ta1(t1,a1),ta2(t2,a2);
-		// externe haut gauche
-		taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
-		// externe bas droite
-		taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
-		// remove the Mark  UnMarkSwap 
-		t1->SetUnMarkUnSwap(ap1);
-		t2->SetUnMarkUnSwap(ap2);
-		// interne 
-		tas1.SetAdj2(tas2);
-
-		t1->det = det1;
-		t2->det = det2;
-
-		t1->SetTriangleContainingTheVertex();
-		t2->SetTriangleContainingTheVertex();
-	} // end swap 
-	/*}}}1*/
 	/*FUNCTION CloseBoundaryEdge{{{1*/
 	TriangleAdjacent CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
@@ -5655,4 +5610,125 @@
 	} 
 	/*}}}1*/
+/*FUNCTION ForceEdge{{{1*/
+int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  { 
+	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
+
+	int NbSwap =0;
+	if (!a.t || !b.t){ // the 2 vertex is in a mesh
+		throw ErrorException(__FUNCT__,exprintf("!a.t || !b.t"));
+	}
+	int k=0;
+	taret=TriangleAdjacent(0,0); // erreur 
+
+	TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
+	Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
+	// we turn around a in the  direct sens  
+
+	Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
+	if(v2) // normal case 
+	 det2 = det(*v2,a,b);
+	else { // no chance infini vertex try the next
+		tta= Previous(Adj(tta));
+		v2 = tta.EdgeVertex(0);
+		vbegin =v2;
+		if (!v2){
+			throw ErrorException(__FUNCT__,exprintf("!v2"));
+		}
+		det2 = det(*v2,a,b);
+	}
+
+	while (v2 != &b) {
+		TriangleAdjacent tc = Previous(Adj(tta));    
+		v1 = v2; 
+		v2 = tc.EdgeVertex(0);
+		det1 = det2;
+		det2 =  v2 ? det(*v2,a,b): det2; 
+
+		if((det1 < 0) && (det2 >0)) { 
+			// try to force the edge 
+			Vertex * va = &a, *vb = &b;
+			tc = Previous(tc);
+			if (!v1 || !v2){
+				throw ErrorException(__FUNCT__,exprintf("!v1 || !v2"));
+			}
+			Icoor2 detss = 0,l=0,ks;
+			while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
+			 if(l++ > 10000000) {
+				 throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
+			 }
+			Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
+			if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
+				tc.SetLock();
+				a.Optim(1,0);
+				b.Optim(1,0);
+				taret = tc;
+				return NbSwap;
+			}
+			else 
+			  {
+				taret = tc;
+				return -2; // error  boundary is crossing
+			  }
+		}
+		tta = tc;
+		k++;
+		if (k>=2000){
+			throw ErrorException(__FUNCT__,exprintf("k>=2000"));
+		}
+		if ( vbegin == v2 ) return -1;// error 
+	}
+
+	tta.SetLock();
+	taret=tta;
+	a.Optim(1,0);
+	b.Optim(1,0);
+	return NbSwap; 
+}
+/*}}}1*/
+/*FUNCTION swap{{{1*/
+void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){ 
+	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
+	// --------------------------------------------------------------
+	// short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
+	//                               
+	//               sb                     sb    
+	//             / | \                   /   \                      !
+	//         as1/  |  \                 /a2   \                     !
+	//           /   |   \               /    t2 \                    !
+	//       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
+	//          \  a1|a2  /             \   as1   /  
+	//           \   |   /               \ t1    /   
+	//            \  |  / as2             \   a1/    
+	//             \ | /                   \   /     
+	//              sa                       sa   
+	//  -------------------------------------------------------------
+	int as1 = NextEdge[a1];
+	int as2 = NextEdge[a2];
+	int ap1 = PreviousEdge[a1];
+	int ap2 = PreviousEdge[a2];
+	(*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
+	(*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
+	// mise a jour des 2 adjacences externes 
+	TriangleAdjacent taas1 = t1->Adj(as1),
+						  taas2 = t2->Adj(as2),
+						  tas1(t1,as1), tas2(t2,as2),
+						  ta1(t1,a1),ta2(t2,a2);
+	// externe haut gauche
+	taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
+	// externe bas droite
+	taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
+	// remove the Mark  UnMarkSwap 
+	t1->SetUnMarkUnSwap(ap1);
+	t2->SetUnMarkUnSwap(ap2);
+	// interne 
+	tas1.SetAdj2(tas2);
+
+	t1->det = det1;
+	t2->det = det2;
+
+	t1->SetTriangleContainingTheVertex();
+	t2->SetTriangleContainingTheVertex();
+} // end swap 
+/*}}}1*/
 	/*FUNCTION SwapForForcingEdge{{{1*/
 	int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
@@ -5743,80 +5819,4 @@
 	}
 	/*}}}1*/
-	/*FUNCTION ForceEdge{{{1*/
-	int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  { 
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
-
-		int NbSwap =0;
-		if (!a.t || !b.t){ // the 2 vertex is in a mesh
-			throw ErrorException(__FUNCT__,exprintf("!a.t || !b.t"));
-		}
-		int k=0;
-		taret=TriangleAdjacent(0,0); // erreur 
-
-		TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
-		Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
-		// we turn around a in the  direct sens  
-
-		Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
-		if(v2) // normal case 
-		 det2 = det(*v2,a,b);
-		else { // no chance infini vertex try the next
-			tta= Previous(Adj(tta));
-			v2 = tta.EdgeVertex(0);
-			vbegin =v2;
-			if (!v2){
-				throw ErrorException(__FUNCT__,exprintf("!v2"));
-			}
-			det2 = det(*v2,a,b);
-		}
-
-		while (v2 != &b) {
-			TriangleAdjacent tc = Previous(Adj(tta));    
-			v1 = v2; 
-			v2 = tc.EdgeVertex(0);
-			det1 = det2;
-			det2 =  v2 ? det(*v2,a,b): det2; 
-
-			if((det1 < 0) && (det2 >0)) { 
-				// try to force the edge 
-				Vertex * va = &a, *vb = &b;
-				tc = Previous(tc);
-				if (!v1 || !v2){
-					throw ErrorException(__FUNCT__,exprintf("!v1 || !v2"));
-				}
-				Icoor2 detss = 0,l=0,ks;
-				while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
-				 if(l++ > 10000000) {
-					 throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
-				 }
-				Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
-				if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
-					tc.SetLock();
-					a.Optim(1,0);
-					b.Optim(1,0);
-					taret = tc;
-					return NbSwap;
-				}
-				else 
-				  {
-					taret = tc;
-					return -2; // error  boundary is crossing
-				  }
-			}
-			tta = tc;
-			k++;
-			if (k>=2000){
-				throw ErrorException(__FUNCT__,exprintf("k>=2000"));
-			}
-			if ( vbegin == v2 ) return -1;// error 
-		}
-
-		tta.SetLock();
-		taret=tta;
-		a.Optim(1,0);
-		b.Optim(1,0);
-		return NbSwap; 
-	}
-	/*}}}1*/
 
 }
Index: /issm/trunk/src/c/Bamgx/objects/Triangles.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangles.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Triangles.h	(revision 3263)
@@ -106,12 +106,8 @@
 			void ShowHistogram() const;
 			void ShowRegulaty() const;
-			void ReMakeTriangleContainingTheVertex();
-			void UnMarkUnSwapTriangle();
 			void SmoothMetric(double raisonmax) ;
 			void BoundAnisotropy(double anisomax,double hminaniso= 1e-100) ;
 			void MaxSubDivision(double maxsubdiv);
 			Edge** MakeGeometricalEdgeToEdge();
-			void SetVertexFieldOn();  
-			void SetVertexFieldOnBTh();
 			long SplitInternalEdgeWithBorderVertices();
 			void MakeQuadrangles(double costheta);
@@ -152,4 +148,25 @@
 			int  CrackMesh();
 
+			//Inline methods
+			inline  void ReMakeTriangleContainingTheVertex(){
+				for (int i=0;i<nbv;i++) vertices[i].vint=0, vertices[i].t=0;
+				for (int i=0;i<nbt;i++) triangles[i].SetTriangleContainingTheVertex();
+			}
+			inline  void  UnMarkUnSwapTriangle(){
+				for (int i=0;i<nbt;i++)
+				 for(int j=0;j<3;j++)
+				  triangles[i].SetUnMarkUnSwap(j);
+			  }
+			inline  void  SetVertexFieldOn(){
+				for (int i=0;i<nbv;i++)                    vertices[i].onGeometry=0;
+				for (int j=0;j<NbVerticesOnGeomVertex;j++) VerticesOnGeomVertex[j].SetOn();
+				for (int k=0;k<NbVerticesOnGeomEdge;k++ )  VerticesOnGeomEdge[k].SetOn();
+			}	       
+			inline  void   SetVertexFieldOnBTh(){
+				for (int i=0;i<nbv;i++)                 vertices[i].onGeometry=0;
+				for (int j=0;j<NbVertexOnBThVertex;j++) VertexOnBThVertex[j].SetOnBTh();
+				for (int k=0;k<NbVertexOnBThEdge;k++ )  VertexOnBThEdge[k].SetOnBTh();
+			}
+
 		private:
 			void GeomToTriangles1(long nbvx,BamgOpts* bamgopts,int KeepVertices=1);// the real constructor mesh adaption
@@ -159,4 +176,43 @@
 	};
 
+	/*Intermediary*/
+	TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
+	TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
+	void  swap(Triangle *t1,short a1,
+				Triangle *t2,short a2,
+				Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);
+	int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,
+				TriangleAdjacent & tt1,Icoor2 & dets1,
+				Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
+	int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret) ;
+	inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
+		return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
+	}
+	inline TriangleAdjacent Next(const TriangleAdjacent & ta){
+		return TriangleAdjacent(ta.t,NextEdge[ta.a]);
+	}
+	inline  TriangleAdjacent Adj(const TriangleAdjacent & a){
+		return  a.Adj();
+	}
+	inline void Adj(GeometricalEdge * & on,int &i){
+		int j=i;i=on->DirAdj[i];on=on->Adj[j];
+	}
+	inline double qualite(const Vertex &va,const Vertex &vb,const Vertex &vc){
+		double ret; 
+		I2 ia=va,ib=vb,ic=vc;
+		I2 ab=ib-ia,bc=ic-ib,ac=ic-ia;
+		Icoor2 deta=Det(ab,ac);
+		if (deta <=0) ret = -1;
+		else {
+			double a = sqrt((double) (ac,ac)),
+					 b = sqrt((double) (bc,bc)),
+					 c = sqrt((double) (ab,ab)),
+					 p = a+b+c;
+			double h= Max(Max(a,b),c),ro=deta/p;
+			ret = ro/h;
+		}
+		return ret;
+	}
+
 }
 #endif
Index: /issm/trunk/src/c/Bamgx/objects/Vertex.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Vertex.cpp	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Vertex.cpp	(revision 3263)
@@ -4,5 +4,5 @@
 #include <ctime>
 
-#include "../BamgObjects.h"
+#include "BamgObjects.h"
 #include "../shared/shared.h"
 
@@ -209,4 +209,17 @@
 	}
 	/*}}}*/
+	/*FUNCTION Vertex::Optim {{{1*/
+	long Vertex::Optim(int i,int koption){ 
+		long ret=0;
+		if ( t && (vint >= 0 ) && (vint <3) ){
+			ret = t->Optim(vint,koption);
+			if(!i){
+				t =0; // for no future optime 
+				vint= 0;
+			}
+		}
+		return ret;
+	}
+	/*}}}*/
 
 	/*Intermediary*/
Index: /issm/trunk/src/c/Bamgx/objects/Vertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Vertex.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/Vertex.h	(revision 3263)
@@ -48,8 +48,8 @@
 			void  Echo();
 			int   ref() const { return ReferenceNumber;}
+			long  Optim(int =1,int =0); 
 
 			//inline functions
-			inline long Optim(int =1,int =0); 
-			inline void Set(const Vertex & rec,const Triangles &,Triangles &);
+			inline void Set(const Vertex &rec,const Triangles & ,Triangles & ){*this=rec;}
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.cpp	(revision 3263)
@@ -0,0 +1,24 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "VertexOnEdge.h"
+#include "Triangles.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "VertexOnEdge"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION VertexOnEdge::Set {{{1*/
+	void VertexOnEdge::Set(const Triangles & Th ,long i,Triangles & ThNew){
+		*this = Th.VertexOnBThEdge[i];  
+		v = ThNew.vertices + Th.Number(v);
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h	(revision 3263)
@@ -35,7 +35,5 @@
 			//Methods
 			void SetOnBTh(){v->onBackgroundEdge=this;v->vint=IsVertexOnEdge;}  
-
-			//Inline methods
-			inline void Set(const Triangles &,long,Triangles &);  
+			void Set(const Triangles &,long,Triangles &);  
 	};
 
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.cpp	(revision 3263)
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "VertexOnGeom.h"
+#include "Triangles.h"
+#include "Geometry.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "VertexOnGeom"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION VertexOnGeom::Set {{{1*/
+	void VertexOnGeom::Set(const VertexOnGeom & rec,const Triangles & Th ,Triangles & ThNew){
+		*this = rec;  
+		mv = ThNew.vertices + Th.Number(mv);
+		if (gv)
+		 if (abscisse < 0 )
+		  gv = ThNew.Gh.vertices + Th.Gh.Number(gv);
+		 else
+		  ge = ThNew.Gh.edges + Th.Gh.Number(ge);
+
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h	(revision 3263)
@@ -46,6 +46,6 @@
 
 			//Inline methods
-			inline void Set(const Triangles &,long,Triangles &);
-			inline void Set(const VertexOnGeom&,const Triangles &,Triangles &);  
+			//inline void Set(const Triangles &,long,Triangles &);
+			void Set(const VertexOnGeom&,const Triangles &,Triangles &);  
 
 	};
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.cpp	(revision 3263)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.cpp	(revision 3263)
@@ -0,0 +1,24 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "VertexOnVertex.h"
+#include "Triangles.h"
+
+#undef __FUNCT__ 
+#define __FUNCT__ "VertexOnVertex"
+
+namespace bamg {
+
+	/*Constructors/Destructors*/
+
+	/*Methods*/
+	/*FUNCTION VertexOnVertex::Set{{{1*/
+	void VertexOnVertex::Set(const Triangles &Th ,long i,Triangles &ThNew) { 
+		*this = Th.VertexOnBThVertex[i];  
+		v     = ThNew.vertices + Th.Number(v);
+	}
+	/*}}}*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h	(revision 3263)
@@ -27,7 +27,5 @@
 			//Methods
 			void SetOnBTh(){v->onBackgroundVertex=bv;v->vint=IsVertexOnVertex;}
-
-			//Inline methods
-			inline void Set(const Triangles &,long,Triangles &);
+			void Set(const Triangles &,long,Triangles &);
 	};
 
Index: sm/trunk/src/c/Bamgx/shared/Adj.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/Adj.h	(revision 3262)
+++ 	(revision )
@@ -1,19 +1,0 @@
-#ifndef _ADJ_H_
-#define _ADJ_H_
-
-#include "../meshtype.h"
-#include "../objects/TriangleAdjacent.h"
-#include "../objects/GeometricalEdge.h"
-
-namespace bamg {
-
-	inline  TriangleAdjacent Adj(const TriangleAdjacent & a){
-		return  a.Adj();
-	}
-
-	inline void Adj(GeometricalEdge * & on,int &i){
-		int j=i;i=on->DirAdj[i];on=on->Adj[j];
-	}
-
-}
-#endif
Index: sm/trunk/src/c/Bamgx/shared/FindTriangleAdjacent.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/FindTriangleAdjacent.h	(revision 3262)
+++ 	(revision )
@@ -1,41 +1,0 @@
-#ifndef _FINDTRIANGLEADJACENT_H_
-#define _FINDTRIANGLEADJACENT_H_
-
-#include "../meshtype.h"
-#include "../objects/Edge.h"
-
-namespace bamg {
-
-	inline TriangleAdjacent FindTriangleAdjacent(Edge &E){
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
-
-		Vertex * a = E.v[0];
-		Vertex * b = E.v[1];
-
-		Triangle * t = a->t;
-		int i = a->vint;
-		TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
-		if (!t || i<0 || i>=3){
-			throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
-		}
-		if ( a!=(*t)(i)){
-			throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
-		}
-		int k=0;
-		do { // turn around vertex in direct sens (trigo)
-			k++;
-			if (k>=20000){
-				throw ErrorException(__FUNCT__,exprintf("k>=20000"));
-			}
-			//  in no crack => ta.EdgeVertex(1) == a otherwise ??? 
-			if (ta.EdgeVertex(1) ==  a && ta.EdgeVertex(0) ==  b) return ta; // find 
-			ta = ta.Adj();
-			if (ta.EdgeVertex(0) ==  a && ta.EdgeVertex(1) ==  b) return ta; // find 
-			--ta;
-		} while (t != (Triangle *)ta);
-		throw ErrorException(__FUNCT__,exprintf("FindTriangleAdjacent: triangle not found"));
-		return TriangleAdjacent(0,0);//for compiler
-	}
-
-}
-#endif
Index: sm/trunk/src/c/Bamgx/shared/Next.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/Next.h	(revision 3262)
+++ 	(revision )
@@ -1,14 +1,0 @@
-#ifndef _NEXT_H_
-#define _NEXT_H_
-
-#include "../meshtype.h"
-#include "../objects/TriangleAdjacent.h"
-
-namespace bamg {
-
-	inline TriangleAdjacent Next(const TriangleAdjacent & ta){
-		return TriangleAdjacent(ta.t,NextEdge[ta.a]);
-	}
-
-}
-#endif
Index: sm/trunk/src/c/Bamgx/shared/Previous.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/Previous.h	(revision 3262)
+++ 	(revision )
@@ -1,14 +1,0 @@
-#ifndef _PREVIOUS_H_
-#define _PREVIOUS_H_
-
-#include "../meshtype.h"
-#include "../objects/TriangleAdjacent.h"
-
-namespace bamg {
-
-	inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
-		return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
-	}
-
-}
-#endif
Index: sm/trunk/src/c/Bamgx/shared/TheVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/TheVertex.h	(revision 3262)
+++ 	(revision )
@@ -1,40 +1,0 @@
-#ifndef _THEVERTEX_H_
-#define _THEVERTEX_H_
-
-#include "../meshtype.h"
-#include "../objects/Vertex.h"
-
-namespace bamg {
-
-	inline Vertex* TheVertex(Vertex * a){// for remove crak in mesh 
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
-
-		// give a unique vertex with smallest number
-		// in case on crack in mesh 
-		Vertex * r(a), *rr;
-		Triangle * t = a->t;
-		int i = a->vint;
-		TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
-		if (!t || i<0 || i>=3){
-			throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
-		}
-		if ( a!=(*t)(i)){
-			throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
-		}
-		int k=0;
-		do { // turn around vertex in direct sens (trigo)
-			k++;
-			if (k>=20000){
-				throw ErrorException(__FUNCT__,exprintf("k>=20000"));
-			}
-			//  in no crack => ta.EdgeVertex(1) == a
-			if ((rr=ta.EdgeVertex(0)) < r) r = rr;
-			ta = ta.Adj();
-			if ((rr=ta.EdgeVertex(1)) < r) r =rr;
-			--ta;
-		} while (t != (Triangle*) ta);  
-		return r;
-	}
-
-}
-#endif
Index: sm/trunk/src/c/Bamgx/shared/qualite.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/qualite.h	(revision 3262)
+++ 	(revision )
@@ -1,27 +1,0 @@
-#ifndef _QUALITE_H_
-#define _QUALITE_H_
-
-#include "../meshtype.h"
-#include "../objects/Vertex.h"
-
-namespace bamg {
-
-	inline double qualite(const Vertex &va,const Vertex &vb,const Vertex &vc){
-		double ret; 
-		I2 ia=va,ib=vb,ic=vc;
-		I2 ab=ib-ia,bc=ic-ib,ac=ic-ia;
-		Icoor2 deta=Det(ab,ac);
-		if (deta <=0) ret = -1;
-		else {
-			double a = sqrt((double) (ac,ac)),
-					 b = sqrt((double) (bc,bc)),
-					 c = sqrt((double) (ab,ab)),
-					 p = a+b+c;
-			double h= Max(Max(a,b),c),ro=deta/p;
-			ret = ro/h;
-		}
-		return ret;
-	}
-
-}
-#endif
Index: /issm/trunk/src/c/Bamgx/shared/shared.h
===================================================================
--- /issm/trunk/src/c/Bamgx/shared/shared.h	(revision 3262)
+++ /issm/trunk/src/c/Bamgx/shared/shared.h	(revision 3263)
@@ -8,10 +8,4 @@
 
 #include "BigPrimeNumber.h"
-#include "qualite.h"
-#include "Next.h"
-#include "Previous.h"
-#include "Adj.h"
-#include "TheVertex.h"
-#include "FindTriangleAdjacent.h"
 
 #endif
Index: /issm/trunk/src/c/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp
===================================================================
--- /issm/trunk/src/c/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp	(revision 3262)
+++ /issm/trunk/src/c/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp	(revision 3263)
@@ -16,6 +16,5 @@
 #include <stdio.h>
 #include <string.h>
-#include "../Bamgx/BamgObjects.h"
-#include "../Bamgx/objects/QuadTree.h"
+#include "../Bamgx/objects/BamgObjects.h"
 
 using namespace bamg;
Index: /issm/trunk/src/c/Makefile.am
===================================================================
--- /issm/trunk/src/c/Makefile.am	(revision 3262)
+++ /issm/trunk/src/c/Makefile.am	(revision 3263)
@@ -334,12 +334,20 @@
 					./Bamgx/meshtype.h\
 					./Bamgx/objects/CrackedEdge.h\
+					./Bamgx/objects/CrackedEdge.cpp\
+					./Bamgx/objects/CrackedTriangle.h\
+					./Bamgx/objects/CrackedTriangle.cpp\
 					./Bamgx/objects/Curve.h\
+					./Bamgx/objects/Curve.cpp\
 					./Bamgx/objects/Direction.h\
+					./Bamgx/objects/Direction.cpp\
 					./Bamgx/objects/DoubleAndInt.h\
 					./Bamgx/objects/Edge.h\
+					./Bamgx/objects/Edge.cpp\
+					./Bamgx/objects/GeometricalEdge.h\
 					./Bamgx/objects/GeometricalEdge.cpp\
-					./Bamgx/objects/GeometricalEdge.h\
 					./Bamgx/objects/GeometricalSubDomain.h\
+					./Bamgx/objects/GeometricalSubDomain.cpp\
 					./Bamgx/objects/GeometricalVertex.h\
+					./Bamgx/objects/GeometricalVertex.cpp\
 					./Bamgx/objects/Geometry.cpp\
 					./Bamgx/objects/Geometry.h\
@@ -355,13 +363,11 @@
 					./Bamgx/objects/SetOfE4.h\
 					./Bamgx/objects/SubDomain.h\
+					./Bamgx/objects/SubDomain.cpp\
 					./Bamgx/objects/TriangleAdjacent.h\
+					./Bamgx/objects/TriangleAdjacent.cpp\
 					./Bamgx/objects/Triangle.cpp\
 					./Bamgx/objects/Triangle.h\
 					./Bamgx/shared/BigPrimeNumber.h\
 					./Bamgx/shared/BigPrimeNumber.cpp\
-					./Bamgx/shared/Adj.h\
-					./Bamgx/shared/Next.h\
-					./Bamgx/shared/Previous.h\
-					./Bamgx/shared/qualite.h\
 					./Bamgx/objects/Triangles.cpp\
 					./Bamgx/objects/Triangles.h\
@@ -369,9 +375,10 @@
 					./Bamgx/objects/Vertex.h\
 					./Bamgx/objects/VertexOnEdge.h\
+					./Bamgx/objects/VertexOnEdge.cpp\
 					./Bamgx/objects/VertexOnGeom.h\
+					./Bamgx/objects/VertexOnGeom.cpp\
 					./Bamgx/objects/VertexOnVertex.h\
-					./Bamgx/shared/FindTriangleAdjacent.h\
-					./Bamgx/shared/shared.h\
-					./Bamgx/shared/TheVertex.h
+					./Bamgx/objects/VertexOnVertex.cpp\
+					./Bamgx/shared/shared.h
 
 
@@ -706,12 +713,20 @@
 					./Bamgx/meshtype.h\
 					./Bamgx/objects/CrackedEdge.h\
+					./Bamgx/objects/CrackedEdge.cpp\
+					./Bamgx/objects/CrackedTriangle.h\
+					./Bamgx/objects/CrackedTriangle.cpp\
 					./Bamgx/objects/Curve.h\
+					./Bamgx/objects/Curve.cpp\
 					./Bamgx/objects/Direction.h\
+					./Bamgx/objects/Direction.cpp\
 					./Bamgx/objects/DoubleAndInt.h\
 					./Bamgx/objects/Edge.h\
+					./Bamgx/objects/Edge.cpp\
+					./Bamgx/objects/GeometricalEdge.h\
 					./Bamgx/objects/GeometricalEdge.cpp\
-					./Bamgx/objects/GeometricalEdge.h\
 					./Bamgx/objects/GeometricalSubDomain.h\
+					./Bamgx/objects/GeometricalSubDomain.cpp\
 					./Bamgx/objects/GeometricalVertex.h\
+					./Bamgx/objects/GeometricalVertex.cpp\
 					./Bamgx/objects/Geometry.cpp\
 					./Bamgx/objects/Geometry.h\
@@ -727,13 +742,11 @@
 					./Bamgx/objects/SetOfE4.h\
 					./Bamgx/objects/SubDomain.h\
+					./Bamgx/objects/SubDomain.cpp\
 					./Bamgx/objects/TriangleAdjacent.h\
+					./Bamgx/objects/TriangleAdjacent.cpp\
 					./Bamgx/objects/Triangle.cpp\
 					./Bamgx/objects/Triangle.h\
 					./Bamgx/shared/BigPrimeNumber.h\
 					./Bamgx/shared/BigPrimeNumber.cpp\
-					./Bamgx/shared/Adj.h\
-					./Bamgx/shared/Next.h\
-					./Bamgx/shared/Previous.h\
-					./Bamgx/shared/qualite.h\
 					./Bamgx/objects/Triangles.cpp\
 					./Bamgx/objects/Triangles.h\
@@ -741,9 +754,10 @@
 					./Bamgx/objects/Vertex.h\
 					./Bamgx/objects/VertexOnEdge.h\
+					./Bamgx/objects/VertexOnEdge.cpp\
 					./Bamgx/objects/VertexOnGeom.h\
+					./Bamgx/objects/VertexOnGeom.cpp\
 					./Bamgx/objects/VertexOnVertex.h\
-					./Bamgx/shared/FindTriangleAdjacent.h\
-					./Bamgx/shared/shared.h\
-					./Bamgx/shared/TheVertex.h
+					./Bamgx/objects/VertexOnVertex.cpp\
+					./Bamgx/shared/shared.h
 
 libpISSM_a_CXXFLAGS = -fPIC -D_PARALLEL_   -D_C_ $(CXXOPTFLAGS)
Index: /issm/trunk/src/c/include/macros.h
===================================================================
--- /issm/trunk/src/c/include/macros.h	(revision 3262)
+++ /issm/trunk/src/c/include/macros.h	(revision 3263)
@@ -3,12 +3,9 @@
  */
 
-
 #ifndef _MACROS_H_
 #define _MACROS_H_
 
-
 /*Printing macro: */
 #define _printf_(...) PrintfFunction(__VA_ARGS__)
-
 
 /*The following macros hide the error exception handling in a matlab module. Just put 
@@ -31,8 +28,5 @@
 	}
 
-
-
 #else 
-
 
 #define MODULEBOOT(); \
@@ -52,3 +46,2 @@
 
 #endif
-
Index: /issm/trunk/src/c/include/types.h
===================================================================
--- /issm/trunk/src/c/include/types.h	(revision 3262)
+++ /issm/trunk/src/c/include/types.h	(revision 3263)
@@ -5,5 +5,4 @@
 #ifndef _TYPES_H_
 #define  _TYPES_H_
-
 
 /*Define abstract type for I/O: */
@@ -19,3 +18,2 @@
 
 #endif //ifndef _TYPES_H_
-