Index: /issm/trunk/src/c/objects/Bamg/AdjacentTriangle.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/AdjacentTriangle.cpp	(revision 5143)
+++ /issm/trunk/src/c/objects/Bamg/AdjacentTriangle.cpp	(revision 5143)
@@ -0,0 +1,76 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "AdjacentTriangle.h"
+#include "Mesh.h"
+
+namespace bamg {
+
+
+	/*Constructors/Destructors*/
+	//See header file
+
+	/*Methods*/
+	/*FUNCTION AdjacentTriangle::Locked {{{1*/
+	int  AdjacentTriangle::Locked() const {
+		return t->TriaAdjSharedEdge[a] & 4;
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::MarkUnSwap {{{1*/
+	int  AdjacentTriangle::MarkUnSwap() const {
+		return t->TriaAdjSharedEdge[a] & 8;
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::GetAllFlag_UnSwap {{{1*/
+	int  AdjacentTriangle::GetAllFlag_UnSwap() const {
+		// take all flag except MarkUnSwap
+		return t->TriaAdjSharedEdge[a] & 1012;
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::SetLock {{{1*/
+	void AdjacentTriangle::SetLock(){
+		t->SetLocked(a);
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::Adj {{{1*/
+	AdjacentTriangle AdjacentTriangle::Adj() const {
+		return  t->Adj(a);
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::EdgeVertex {{{1*/
+	BamgVertex* AdjacentTriangle::EdgeVertex(const int & i) const {
+		return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::OppositeVertex {{{1*/
+	BamgVertex* AdjacentTriangle::OppositeVertex() const {
+		return t->TriaVertices[bamg::OppositeVertex[a]]; 
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::det {{{1*/
+	Icoor2 & AdjacentTriangle::det() const {
+		return t->det;
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::swap {{{1*/
+	int AdjacentTriangle::swap(){
+		return  t->swap(a);
+	}
+	/*}}}*/
+	/*FUNCTION AdjacentTriangle::SetAdj2 {{{1*/
+	void AdjacentTriangle::SetAdj2(const AdjacentTriangle & 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/objects/Bamg/AdjacentTriangle.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/AdjacentTriangle.h	(revision 5143)
+++ /issm/trunk/src/c/objects/Bamg/AdjacentTriangle.h	(revision 5143)
@@ -0,0 +1,46 @@
+#ifndef _TRIANGLEADJACENT_H_
+#define _TRIANGLEADJACENT_H_
+
+#include "./include.h"
+#include "./BamgVertex.h"
+
+namespace bamg {
+
+	//classes
+	class Triangle;
+	class Triangle;
+
+	class AdjacentTriangle {
+
+		public:
+			Triangle* t; //pointer toward the triangle
+			int  a;      //Edge number
+
+			//Constructors
+			AdjacentTriangle() {};
+			AdjacentTriangle(Triangle* tt,int  aa): t(tt),a(aa &3) {};
+
+			//Operators
+			operator Triangle * () const {return t;}
+			operator Triangle & () const {return *t;}
+			operator int() const {return a;}
+			AdjacentTriangle & operator++(){ a= NextEdge[a]; return *this; }
+			AdjacentTriangle operator--(){ a= PreviousEdge[a]; return *this; }
+
+			//Methods
+
+			//Methods
+			int  Locked() const;
+			int  MarkUnSwap() const;
+			int  GetAllFlag_UnSwap() const;
+			void SetLock();
+			void SetAdj2(const AdjacentTriangle &ta, int l=0);
+			int  swap();
+			AdjacentTriangle Adj() const;
+			BamgVertex* EdgeVertex(const int & i) const;
+			BamgVertex* OppositeVertex() const;
+			Icoor2& det() const;
+	};
+}
+#endif
+
Index: /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp	(revision 5143)
@@ -52,5 +52,5 @@
 		if (tstart->det <0){ // outside
 			double ba,bb;
-			TriangleAdjacent edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
+			AdjacentTriangle edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
 			tstart = edge;
 			vP.m= Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));
Index: /issm/trunk/src/c/objects/Bamg/Edge.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Edge.h	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Edge.h	(revision 5143)
@@ -16,14 +16,14 @@
 
 		public:
-			BamgVertex* v[2];
-			long ref;
-			GeometricalEdge* onGeometry;
-			Edge* adj[2]; // the 2 adj edges if on the same curve 
+			BamgVertex      *v[2];
+			long             ref;
+			GeometricalEdge *onGeometry;
+			Edge            *adj[2];       // the 2 adj edges if on the same curve
 
 			//Operators
-			BamgVertex & operator[](int i){return *v[i];};
-			BamgVertex * operator()(int i){return v[i];};
-			R2       operator()(double t) const; // return the point 
-			const BamgVertex & operator[](int i) const { return *v[i];};
+			BamgVertex       &operator[](int i){return *v[i];   };
+			BamgVertex       *operator()(int     i){return v[i];};
+			R2                operator()(double  t) const;// return the point
+			const BamgVertex &operator[](int i) const{return *v[i];};
 
 			//Methods
Index: /issm/trunk/src/c/objects/Bamg/GeometricalEdge.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/GeometricalEdge.h	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/GeometricalEdge.h	(revision 5143)
@@ -13,11 +13,11 @@
 
 		public:
-			GeometricalVertex* v[2];
-			long ref;
-			long CurveNumber;
-			R2   tg[2]; // the 2 tangentes (tg[0] =0 => no continuity)
-			GeometricalEdge* Adj[2]; 
-			int DirAdj[2];
-			int flag ;
+			GeometricalVertex *v[2];
+			long               ref;
+			long               CurveNumber;
+			R2                 tg[2];         // the 2 tangentes (tg[0] =0 => no continuity)
+			GeometricalEdge   *Adj[2];
+			int                DirAdj[2];
+			int                flag;
 
 			//Operators
Index: /issm/trunk/src/c/objects/Bamg/Geometry.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Geometry.cpp	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Geometry.cpp	(revision 5143)
@@ -69,10 +69,10 @@
 
 		double Hmin = HUGE_VAL;// the infinie value 
-		int i,j,k,n,i1,i2;
+		int i,j,k,n,i0,i1,i2,i3;
 
 		/*initialize some variables*/
-		verbose=bamgopts->verbose;
-		nbv  = bamggeom->VerticesSize[0];
-		nbe  = bamggeom->EdgesSize[0];
+		verbose= bamgopts->verbose;
+		nbv    = bamggeom->VerticesSize[0];
+		nbe    = bamggeom->EdgesSize[0];
 
 		//some checks
@@ -122,6 +122,6 @@
 		//Edges
 		if (bamggeom->Edges){
-			R2     zero2(0,0);
-			double* len=NULL;
+			R2      zerovector(0,0);
+			double* verticeslength=NULL;
 
 			if(verbose>5) printf("      processing Edges\n");
@@ -129,49 +129,47 @@
 			edges = new GeometricalEdge[nbe];
 
-			//initialize len (length of each edge)
-			len = new double[nbv];
-			for(i=0;i<nbv;i++) len[i]=0;
-
+			//initialize verticeslength (sum of the lengths of the edges holding vertex)
+			verticeslength = new double[nbv];
+			for(i=0;i<nbv;i++) verticeslength[i]=0;
+
+			/*Loop over the edges*/
 			for (i=0;i<nbe;i++){
 
-				//printf("%i th edge of geometry: [%i %i]\n",i+1,(int)bamggeom->Edges[i*3+0],(int)bamggeom->Edges[i*3+1]);
 				i1=(int)bamggeom->Edges[i*3+0]-1; //-1 for C indexing
 				i2=(int)bamggeom->Edges[i*3+1]-1; //-1 for C indexing
+				edges[i].v[0]= vertices + i1;     //pointer toward vertex i1 (=&vertices[i1])
+				edges[i].v[1]= vertices + i2;     //pointer toward vertex i2
 				edges[i].ref=(long)bamggeom->Edges[i*3+2];
 
-				edges[i].v[0]= vertices + i1;
-				edges[i].v[1]= vertices + i2;
-
 				//get length of edge
-				R2    x12=vertices[i2].r-vertices[i1].r;
+				R2     x12=vertices[i2].r-vertices[i1].r;
 				double l12=sqrt((x12,x12));
 				Hmin=Min(Hmin,l12);
 
 				//initialize other fields
-				edges[i].tg[0]=zero2;
-				edges[i].tg[1]=zero2;
+				edges[i].tg[0]=zerovector;
+				edges[i].tg[1]=zerovector;
 				edges[i].DirAdj[0] = edges[i].DirAdj[1] = -1;
-				edges[i].Adj[0] = edges[i].Adj[1] = 0;
+				edges[i].Adj[0] = edges[i].Adj[1] = NULL;
 				edges[i].flag = 0;
 
 				//Cracked?
-				if (edges[i].ref!=1){
-					edges[i].SetCracked();
-				}
+				if (edges[i].ref!=1) edges[i].SetCracked();
 
 				//prepare metric
 				vertices[i1].color++;
 				vertices[i2].color++;
-				len[i1] += l12;
-				len[i2] += l12;
+				verticeslength[i1] += l12;
+				verticeslength[i2] += l12;
 			}
 
 			// definition  the default of the given mesh size 
-			for (i=0;i<nbv;i++) 
-			 if (vertices[i].color > 0) 
-			  vertices[i].m=Metric(len[i] /(double) vertices[i].color);
-			 else 
-			  vertices[i].m=Metric(Hmin);
-			delete [] len;
+			for (i=0;i<nbv;i++) {
+				if (vertices[i].color > 0) 
+				 vertices[i].m=Metric(verticeslength[i] /(double) vertices[i].color);
+				else 
+				 vertices[i].m=Metric(Hmin);
+			}
+			delete [] verticeslength;
 			
 		}
@@ -217,7 +215,6 @@
 				tg.x=bamggeom->TangentAtEdges[k*4+2];
 				tg.y=bamggeom->TangentAtEdges[k*4+3];
-				if (j!=0 && j!=1){
-					ISSMERROR("TangentAtEdges second index should be 1 or 2 only");
-				}
+				if (i<0 || i>=nbe) ISSMERROR("TangentAtEdges first index exceeds matrix dimension");
+				if (j!=0 && j!=1)  ISSMERROR("TangentAtEdges second index should be 1 or 2 only");
 				edges[i].tg[j] = tg;
 			}
@@ -231,9 +228,9 @@
 			for (i=0;i<n;i++) {     
 				j=(int)bamggeom->Corners[i]-1; //for C indexing
-				if (j>nbv-1 || j<0){
-					ISSMERROR("Bad corner definition: should in [0 %i]",nbv);
-				}
+				if (j>nbv-1 || j<0) ISSMERROR("Bad corner definition: should in [0 %i]",nbv);
+				/*Required => at the same time SetRequired and SetCorner*/
 				vertices[j].SetCorner();
-				vertices[j].SetRequired();  }
+				vertices[j].SetRequired();
+			}
 		}
 
@@ -245,8 +242,7 @@
 			for (i=0;i<n;i++) {     
 				j=(int)bamggeom->RequiredVertices[i]-1; //for C indexing
-				if (j>nbv-1 || j<0){
-					ISSMERROR("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
-				}
-				vertices[j].SetRequired();  }
+				if (j>nbv-1 || j<0) ISSMERROR("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
+				vertices[j].SetRequired();
+			}
 		}
 
@@ -258,7 +254,5 @@
 			for (i=0;i<n;i++) {     
 				j=(int)bamggeom->RequiredEdges[i]-1; //for C indexing
-				if (j>nbe-1 || j<0){
-					ISSMERROR("Bad RequiredEdges definition: should in [0 %i]",nbe);
-				}
+				if (j>nbe-1 || j<0) ISSMERROR("Bad RequiredEdges definition: should in [0 %i]",nbe);
 				edges[j].SetRequired();  
 			}
@@ -267,10 +261,9 @@
 		//SubDomain
 		if(bamggeom->SubDomains){
-			long i0,i1,i2,i3;
 			if(verbose>5) printf("      processing SubDomains\n");
 			if (bamggeom->SubDomainsSize[1]!=4) ISSMERROR("SubDomains should have 4 columns");
 			NbSubDomains=bamggeom->SubDomainsSize[0];
 			subdomains = new GeometricalSubDomain[NbSubDomains];
-			for (i=0;i<NbSubDomains;i++) {
+			for (i=0;i<NbSubDomains;i++){
 				i0=(int)bamggeom->SubDomains[i*4+0];
 				i1=(int)bamggeom->SubDomains[i*4+1];
Index: /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp	(revision 5143)
@@ -254,5 +254,5 @@
 				ilast=ifirst;
 				double ba,bb;
-				TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
+				AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
 				BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 				NewItem(A,Metric(ba,v0,bb,v1));
@@ -260,5 +260,5 @@
 				// test if the point b is in the same side
 				if (det(v0.i,v1.i,b)>=0) {
-					TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
+					AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
 					BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 					NewItem(A,Metric(ba,v0,bb,v1));
@@ -284,5 +284,5 @@
 				else if (detj<=0) // go to j direction on gamma
 				 ocut = NextEdge[ocut];         
-				TriangleAdjacent tadj =t->Adj(ocut);
+				AdjacentTriangle tadj =t->Adj(ocut);
 				t = tadj;
 				iedge= tadj; 
@@ -290,5 +290,5 @@
 					double ba,bb;
 					long int verbose=2;
-					TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
+					AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
 					BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 					NewItem(A,Metric(ba,v0,bb,v1));
@@ -304,5 +304,5 @@
 				t=tbegin;
 				double ba,bb;
-				TriangleAdjacent edge=CloseBoundaryEdge(b,t,ba,bb);
+				AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb);
 				NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)));
 				return;
@@ -412,10 +412,10 @@
 					ilast=NewItem(t, ba[0],ba[1],ba[2]);      
 
-					TriangleAdjacent ta =t->Adj(ocut);
+					AdjacentTriangle ta =t->Adj(ocut);
 					t = ta;
 					iedge= ta; 
 					if (t->det <= 0)  {
 						double ba,bb;
-						TriangleAdjacent edge=CloseBoundaryEdge(b,t,ba,bb);
+						AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb);
 						NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)));
 						return;
Index: /issm/trunk/src/c/objects/Bamg/Mesh.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Mesh.cpp	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Mesh.cpp	(revision 5143)
@@ -263,5 +263,5 @@
 
 		double Hmin = HUGE_VAL;// the infinie value 
-		long i1,i2,i3,iref;
+		long i1,i2,i3;
 		long i,j;
 		Metric M1(1);
@@ -309,9 +309,8 @@
 	void Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){
 
-		int verbose;
-		double Hmin = HUGE_VAL;// the infinie value 
-		long i1,i2,i3,iref;
-		long i,j;
-		long ifgeom=0;
+		int    verbose;
+		double Hmin = HUGE_VAL;    // the infinie value
+		long   i1,i2,i3;
+		long   i,j;
 		Metric M1(1);
 
@@ -349,5 +348,5 @@
 			//other triangles will be added for each edge
 			for (i=0;i<nbt;i++){
-				Triangle & t = triangles[i];
+				Triangle &t=triangles[i];
 				i1=(long)bamgmesh->Triangles[i*4+0]-1; //for C indexing
 				i2=(long)bamgmesh->Triangles[i*4+1]-1; //for C indexing
@@ -1138,5 +1137,5 @@
 			if (nbzerodet == 1) {
 				iedge = OppositeEdge[izerodet];
-				TriangleAdjacent ta = t->Adj(iedge);
+				AdjacentTriangle ta = t->Adj(iedge);
 
 				// the point is on the edge 
@@ -2283,5 +2282,5 @@
 			//Now, we are going to go through the adjacent triangle that hold i1 till
 			//we find one that has the cracked edge
-			TriangleAdjacent ta(tbegin,EdgesVertexTriangle[k][0]);
+			AdjacentTriangle ta(tbegin,EdgesVertexTriangle[k][0]);
 			count=0;
 			do {
@@ -2358,5 +2357,5 @@
 
 			//Force Edges
-			TriangleAdjacent ta(0,0);
+			AdjacentTriangle ta(0,0);
 			for (int i = 0; i < nbe; i++){
 
@@ -2575,5 +2574,5 @@
 					}
 
-					TriangleAdjacent  ta(t,EdgesVertexTriangle[v0->vint][0]);// previous edges
+					AdjacentTriangle  ta(t,EdgesVertexTriangle[v0->vint][0]);// previous edges
 
 					while (1) {
@@ -3072,5 +3071,5 @@
 		if (t->det <0) { // outside
 			double ba,bb;
-			TriangleAdjacent edge= CloseBoundaryEdge(a,t,ba,bb) ;
+			AdjacentTriangle edge= CloseBoundaryEdge(a,t,ba,bb) ;
 			return Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));}
 		else { // inside
@@ -3148,5 +3147,5 @@
 				//Loop over the edges of t
 				for(j=0;j<3;j++){
-					TriangleAdjacent tj(t,j);
+					AdjacentTriangle tj(t,j);
 					BamgVertex &vA = *tj.EdgeVertex(0);
 					BamgVertex &vB = *tj.EdgeVertex(1);
@@ -3157,5 +3156,5 @@
 					if (t->Locked(j)) continue;
 
-					TriangleAdjacent tadjj = t->Adj(j);	  
+					AdjacentTriangle tadjj = t->Adj(j);	  
 					Triangle* ta=tadjj;
 
@@ -3182,5 +3181,5 @@
 			for (i=nbvold;i<nbv;i++){ 
 				BamgVertex*          s  = vertices + i;
-				TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]);
+				AdjacentTriangle ta(s->t, EdgesVertexTriangle[s->vint][1]);
 				Triangle*        tbegin= (Triangle*) ta;
 				long kt;
@@ -3521,5 +3520,5 @@
 
 	//enforce the boundary 
-	TriangleAdjacent ta(0,0);
+	AdjacentTriangle ta(0,0);
 	long nbloss = 0,knbe=0;
 	for ( i = 0; i < nbe; i++){
@@ -3544,5 +3543,5 @@
 			krm++;
 			for (int j=0;j<3;j++){
-				TriangleAdjacent ta =  triangles[i].Adj(j);
+				AdjacentTriangle ta =  triangles[i].Adj(j);
 				Triangle &tta = *(Triangle*)ta;
 				//if edge between remove and not remove 
@@ -4035,5 +4034,5 @@
 			}
 			BamgVertex & vi = vertices[i];
-			TriangleAdjacent ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
+			AdjacentTriangle ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
 			BamgVertex *pvj0 = ta.EdgeVertex(0);
 			while (1) {
@@ -4246,5 +4245,5 @@
 			for(int j=0;j<3;j++)
 			  {
-				const TriangleAdjacent ta = t.Adj(j);
+				const AdjacentTriangle ta = t.Adj(j);
 				const Triangle & tt = ta;
 				if (&tt >= lastT)
@@ -4295,5 +4294,5 @@
 				if (t.Hidden(j)) invisibleedge=j,nbinvisible++;
 
-				const TriangleAdjacent ta = t.Adj(j);
+				const AdjacentTriangle ta = t.Adj(j);
 				const Triangle & tt = ta;
 
@@ -4387,5 +4386,5 @@
 			}
 			// --------------------------
-			TriangleAdjacent ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2));
+			AdjacentTriangle ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2));
 			// save the flag Hidden
 			int hid[]={t0.Hidden(0),t0.Hidden(1),t0.Hidden(2)};
@@ -4744,5 +4743,5 @@
 			ISSMERROR("k>=3");
 		}
-		TriangleAdjacent t1 = t->Adj(jj=ii[0]);
+		AdjacentTriangle t1 = t->Adj(jj=ii[0]);
 		if ((t1.det() < 0 ) && (k == 2))
 		 t1 = t->Adj(jj=ii[1]);
@@ -5453,5 +5452,5 @@
 	/*Intermediary*/
 	/*FUNCTION CloseBoundaryEdge{{{1*/
-	TriangleAdjacent CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
+	AdjacentTriangle CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/
 
@@ -5463,5 +5462,5 @@
 		int kkk=0;  
 		Icoor2 IJ_IA,IJ_AJ;
-		TriangleAdjacent edge(t,OppositeEdge[k]);          
+		AdjacentTriangle edge(t,OppositeEdge[k]);          
 		for (;;edge = dir >0 ? Next(Adj(Next(edge))) : Previous(Adj(Previous(edge)))) {  
 			kkk++;
@@ -5493,5 +5492,5 @@
 	/*}}}1*/
 	/*FUNCTION CloseBoundaryEdgeV2{{{1*/
-	TriangleAdjacent CloseBoundaryEdgeV2(I2 C,Triangle *t, double &a,double &b) { 
+	AdjacentTriangle CloseBoundaryEdgeV2(I2 C,Triangle *t, double &a,double &b) { 
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdgeV2)*/
 		// walk around the vertex 
@@ -5514,9 +5513,9 @@
 		Icoor2 l0 = imax,l1 = imax;
 		double dd2 =  imax;// infinity
-		TriangleAdjacent er; 
+		AdjacentTriangle er; 
 		int  cas=-2;
 		for (int j=0;j<3;j++)
 		  { 
-			TriangleAdjacent ta=t->FindBoundaryEdge(j);
+			AdjacentTriangle ta=t->FindBoundaryEdge(j);
 			if  (! (Triangle *) ta) continue;
 			s0 = ta.EdgeVertex(0);
@@ -5582,5 +5581,5 @@
 		  { 
 			t=er;
-			TriangleAdjacent edge(er); 
+			AdjacentTriangle edge(er); 
 
 			int kkk=0;  
@@ -5642,5 +5641,5 @@
 	/*}}}1*/
 /*FUNCTION ForceEdge{{{1*/
-int ForceEdge(BamgVertex &a, BamgVertex & b,TriangleAdjacent & taret)  { 
+int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret)  { 
 	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
 
@@ -5650,7 +5649,7 @@
 	}
 	int k=0;
-	taret=TriangleAdjacent(0,0); // erreur 
-
-	TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
+	taret=AdjacentTriangle(0,0); // erreur 
+
+	AdjacentTriangle tta(a.t,EdgesVertexTriangle[a.vint][0]);
 	BamgVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
 	// we turn around a in the  direct sens  
@@ -5670,5 +5669,5 @@
 
 	while (v2 != &b) {
-		TriangleAdjacent tc = Previous(Adj(tta));    
+		AdjacentTriangle tc = Previous(Adj(tta));    
 		v1 = v2; 
 		v2 = tc.EdgeVertex(0);
@@ -5741,5 +5740,5 @@
 	(*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
 	// mise a jour des 2 adjacences externes 
-	TriangleAdjacent taas1 = t1->Adj(as1),
+	AdjacentTriangle taas1 = t1->Adj(as1),
 						  taas2 = t2->Adj(as2),
 						  tas1(t1,as1), tas2(t2,as2),
@@ -5763,5 +5762,5 @@
 /*}}}1*/
 	/*FUNCTION SwapForForcingEdge{{{1*/
-	int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
+	int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,AdjacentTriangle & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/
 		// l'arete ta coupe l'arete pva pvb
@@ -5773,5 +5772,5 @@
 		if(tt1.Locked()) return 0; // frontiere croise 
 
-		TriangleAdjacent tt2 = Adj(tt1);
+		AdjacentTriangle tt2 = Adj(tt1);
 		Triangle *t1=tt1,*t2=tt2;// les 2 triangles adjacent
 		short a1=tt1,a2=tt2;// les 2 numero de l arete dans les 2 triangles
Index: /issm/trunk/src/c/objects/Bamg/Mesh.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Mesh.h	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Mesh.h	(revision 5143)
@@ -27,4 +27,10 @@
 			Geometry                    & Gh;                    // Geometry
 			Mesh                        & BTh;                   // Background Mesh Bth== *this =>no background
+			BamgVertex                   *vertices;
+			Triangle                     *triangles;
+			Edge                         *edges;
+			QuadTree                     *quadtree;
+			BamgVertex                  **ordre;
+			SubDomain                    *subdomains;
 			long                          NbRef;                 // counter of ref on the this class if 0 we can delete
 			long                          maxnbv,nbtx;           // nombre max de sommets , de triangles
@@ -35,5 +41,4 @@
 			long                          NbOfTriangleSearchFind;
 			long                          NbOfSwapTriangle;
-			BamgVertex                   *vertices;
 			long                          NbVerticesOnGeomVertex;
 			VertexOnGeom                 *VerticesOnGeomVertex;
@@ -50,9 +55,4 @@
 			R2                            pmin,pmax;             // extrema
 			double                        coefIcoor;             // coef to integer Icoor1;
-			Triangle                     *triangles;
-			Edge                         *edges;
-			QuadTree                     *quadtree;
-			BamgVertex                  **ordre;
-			SubDomain                    *subdomains;
 			ListofIntersectionTriangles   lIntTria;
 
@@ -156,20 +156,20 @@
 
 	/*Intermediary*/
-	TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
-	TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
+	AdjacentTriangle CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
+	AdjacentTriangle CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
 	void  swap(Triangle *t1,short a1,
 				Triangle *t2,short a2,
 				BamgVertex *s1,BamgVertex *s2,Icoor2 det1,Icoor2 det2);
 	int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,
-				TriangleAdjacent & tt1,Icoor2 & dets1,
+				AdjacentTriangle & tt1,Icoor2 & dets1,
 				Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
-	int ForceEdge(BamgVertex &a, BamgVertex & b,TriangleAdjacent & taret) ;
-	inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
-		return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
+	int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret) ;
+	inline AdjacentTriangle Previous(const AdjacentTriangle & ta){
+		return AdjacentTriangle(ta.t,PreviousEdge[ta.a]);
 	}
-	inline TriangleAdjacent Next(const TriangleAdjacent & ta){
-		return TriangleAdjacent(ta.t,NextEdge[ta.a]);
+	inline AdjacentTriangle Next(const AdjacentTriangle & ta){
+		return AdjacentTriangle(ta.t,NextEdge[ta.a]);
 	}
-	inline  TriangleAdjacent Adj(const TriangleAdjacent & a){
+	inline  AdjacentTriangle Adj(const AdjacentTriangle & a){
 		return  a.Adj();
 	}
Index: /issm/trunk/src/c/objects/Bamg/Triangle.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Triangle.cpp	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Triangle.cpp	(revision 5143)
@@ -74,5 +74,5 @@
 	/*}}}*/
 	/*FUNCTION Triangle::FindBoundaryEdge{{{1*/
-	TriangleAdjacent Triangle::FindBoundaryEdge(int i) const{
+	AdjacentTriangle Triangle::FindBoundaryEdge(int i) const{
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindBoundaryEdge)*/
 
@@ -103,5 +103,5 @@
 			outside = !ttc->link;
 			//if both previous triangle are outside, return
-			if (outside+outsidep == 1) return TriangleAdjacent(t,j);
+			if (outside+outsidep == 1) return AdjacentTriangle(t,j);
 
 			//update t and j
@@ -117,5 +117,5 @@
 		} while (this!= t);
 		//not found, return empty triangle
-		return TriangleAdjacent(NULL,0);
+		return AdjacentTriangle(NULL,0);
 	}
 	/*}}}1*/
Index: /issm/trunk/src/c/objects/Bamg/Triangle.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Triangle.h	(revision 5142)
+++ /issm/trunk/src/c/objects/Bamg/Triangle.h	(revision 5143)
@@ -3,5 +3,5 @@
 
 #include "./include.h"
-#include "TriangleAdjacent.h"
+#include "AdjacentTriangle.h"
 
 namespace bamg {
@@ -14,16 +14,16 @@
 	class Triangle {
 
-		friend class TriangleAdjacent;
+		friend class AdjacentTriangle;
 
 		private:
-			BamgVertex*   TriaVertices[3];      // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
-			Triangle* TriaAdjTriangles[3];  // 3 pointers toward the adjacent triangles
-			short     TriaAdjSharedEdge[3]; // number of the edges in the adjacent triangles the edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1
+			BamgVertex *TriaVertices[3];        // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
+			Triangle   *TriaAdjTriangles[3];    // 3 pointers toward the adjacent triangles
+			short       TriaAdjSharedEdge[3];   // edge id in the adjacent triangles. The edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1
 
 		public: 
-			Icoor2 det; // determinant du triangle (2 fois l aire des vertices entieres)
+			Icoor2 det; //Integer determinant (twice its area)
 			union { 
-				Triangle * link ;
-				long color;
+				Triangle *link;
+				long      color;
 			};
 
@@ -49,6 +49,6 @@
 			double QualityQuad(int a,int option=1) const;
 			short  NuEdgeTriangleAdj(int i) const {return TriaAdjSharedEdge[i&3]&3;} // Number of the  adjacent edge in adj tria  
-			TriangleAdjacent FindBoundaryEdge(int i) const;
-			TriangleAdjacent Adj(int i)  const {return TriangleAdjacent(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
+			AdjacentTriangle FindBoundaryEdge(int i) const;
+			AdjacentTriangle Adj(int i)  const {return AdjacentTriangle(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
 			Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];}
 			Triangle* Quadrangle(BamgVertex * & v0,BamgVertex * & v1,BamgVertex * & v2,BamgVertex * & v3) const ;
Index: sm/trunk/src/c/objects/Bamg/TriangleAdjacent.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/TriangleAdjacent.cpp	(revision 5142)
+++ 	(revision )
@@ -1,76 +1,0 @@
-#include <cstdio>
-#include <cstring>
-#include <cmath>
-#include <ctime>
-
-#include "TriangleAdjacent.h"
-#include "Mesh.h"
-
-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::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::Adj {{{1*/
-	TriangleAdjacent TriangleAdjacent::Adj() const {
-		return  t->Adj(a);
-	}
-	/*}}}*/
-	/*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/
-	BamgVertex* TriangleAdjacent::EdgeVertex(const int & i) const {
-		return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
-	}
-	/*}}}*/
-	/*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/
-	BamgVertex* 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: sm/trunk/src/c/objects/Bamg/TriangleAdjacent.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/TriangleAdjacent.h	(revision 5142)
+++ 	(revision )
@@ -1,46 +1,0 @@
-#ifndef _TRIANGLEADJACENT_H_
-#define _TRIANGLEADJACENT_H_
-
-#include "./include.h"
-#include "./BamgVertex.h"
-
-namespace bamg {
-
-	//classes
-	class Triangle;
-	class Triangle;
-
-	class TriangleAdjacent {
-
-		public:
-			Triangle* t; //pointer toward the triangle
-			int  a;      //Edge number
-
-			//Constructors
-			TriangleAdjacent() {};
-			TriangleAdjacent(Triangle* tt,int  aa): t(tt),a(aa &3) {};
-
-			//Operators
-			operator Triangle * () const {return t;}
-			operator Triangle & () const {return *t;}
-			operator int() const {return a;}
-			TriangleAdjacent & operator++(){ a= NextEdge[a]; return *this; }
-			TriangleAdjacent operator--(){ a= PreviousEdge[a]; return *this; }
-
-			//Methods
-
-			//Methods
-			int  Locked() const;
-			int  MarkUnSwap() const;
-			int  GetAllFlag_UnSwap() const;
-			void SetLock();
-			void SetAdj2(const TriangleAdjacent &ta, int l=0);
-			int  swap();
-			TriangleAdjacent Adj() const;
-			BamgVertex* EdgeVertex(const int & i) const;
-			BamgVertex* OppositeVertex() const;
-			Icoor2& det() const;
-	};
-}
-#endif
-
Index: /issm/trunk/src/c/objects/objects.h
===================================================================
--- /issm/trunk/src/c/objects/objects.h	(revision 5142)
+++ /issm/trunk/src/c/objects/objects.h	(revision 5143)
@@ -100,5 +100,5 @@
 #include "./Bamg/Direction.h"
 #include "./Bamg/BamgVertex.h"
-#include "./Bamg/TriangleAdjacent.h"
+#include "./Bamg/AdjacentTriangle.h"
 #include "./Bamg/Edge.h"
 #include "./Bamg/GeometricalVertex.h"