Index: /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/BamgVertex.cpp	(revision 5180)
@@ -156,5 +156,5 @@
 
 		Icoor2 deta[3];
-		I2 IBTh  = BTh.toI2(PNew);
+		I2 IBTh  = BTh.R2ToI2(PNew);
 
 		tstart=BTh.TriangleFindFromCoord(IBTh,deta,tstart);  
@@ -178,5 +178,5 @@
 		vP.r = PNew;
 
-		vP.i = Th.toI2(PNew);
+		vP.i = Th.R2ToI2(PNew);
 
 		BamgVertex vPnew = vP;
Index: /issm/trunk/src/c/objects/Bamg/Geometry.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Geometry.cpp	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/Geometry.cpp	(revision 5180)
@@ -425,5 +425,5 @@
 			then, the integer coordinates are computed using 
 			the transformation ]0,1[^2 -> [0 2^30-1[^2 for a quadtree of depth 30*/
-			vertices[i].i=toI2(vertices[i].r); 
+			vertices[i].i=R2ToI2(vertices[i].r); 
 
 			/*find nearest vertex already present in the quadtree (NULL if empty)*/
@@ -932,6 +932,6 @@
 	}
 	/*}}}1*/
-	/*FUNCTION Geometry::toI2{{{1*/
-	I2 Geometry::toI2(const R2 & P) const {
+	/*FUNCTION Geometry::R2ToI2{{{1*/
+	I2 Geometry::R2ToI2(const R2 & P) const {
 		/*coefIcoor is the coefficient used for integer coordinates:
 		 *                       (x-pmin.x)
Index: /issm/trunk/src/c/objects/Bamg/Geometry.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Geometry.h	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/Geometry.h	(revision 5180)
@@ -48,5 +48,5 @@
 			//Methods
 			void             Echo();
-			I2               toI2(const R2 &P) const;
+			I2               R2ToI2(const R2 &P) const;
 			double           MinimalHmin();
 			double           MaximalHmax();
Index: /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp	(revision 5180)
@@ -234,5 +234,5 @@
 		//  int OnAVertices =0;
 		Icoor2 dt[3];
-		I2 a = Bh.toI2(A) ,b= Bh.toI2(B);// compute  the Icoor a,b
+		I2 a = Bh.R2ToI2(A) ,b= Bh.R2ToI2(B);// compute  the Icoor a,b
 		I2 vi,vj;  
 		int iedge =-1;// not a edge
Index: /issm/trunk/src/c/objects/Bamg/Mesh.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Mesh.cpp	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/Mesh.cpp	(revision 5180)
@@ -2893,6 +2893,6 @@
 		for (i=nbvold;i<nbv;i++){
 			BamgVertex &vi=*ordre[i];
-			vi.i=toI2(vi.r);
-			vi.r=toR2(vi.i);
+			vi.i=R2ToI2(vi.r);
+			vi.r=I2ToR2(vi.i);
 			double hx,hy;
 			vi.m.Box(hx,hy);
@@ -3098,5 +3098,5 @@
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MetricAt)*/
 
-		I2 a = toI2(A);
+		I2 a = R2ToI2(A);
 		Icoor2 deta[3];
 		Triangle * t =TriangleFindFromCoord(a,deta);
@@ -3858,5 +3858,5 @@
 	// generation of integer coord  
 	for (i=0;i<nbv;i++) {
-		vertices[i].i = toI2(vertices[i].r);    
+		vertices[i].i = R2ToI2(vertices[i].r);    
 	}
 
@@ -4229,5 +4229,5 @@
 					ong=Gh.ProjectOnCurve(edges[i],
 								0.5,vertices[k],newVerticesOnGeomEdge[kvg++]);
-					// vertices[k].i = toI2( vertices[k].r);
+					// vertices[k].i = R2ToI2( vertices[k].r);
 					vertices[k].ReferenceNumber = edges[i].ReferenceNumber;
 					vertices[k].DirOfSearch = NoDirOfSearch;
@@ -4241,5 +4241,5 @@
 				vertices[k].GeometricalEdgeHook = 0;
 			  }
-			//vertices[k].i = toI2( vertices[k].r);
+			//vertices[k].i = R2ToI2( vertices[k].r);
 			R2 AB =  vertices[k].r;
 			R2 AA = (A+AB)*0.5;
@@ -4354,5 +4354,5 @@
 							  {
 								vertices[k].r = ((R2) v0+(R2) v1 )/2;
-								//vertices[k].i = toI2( vertices[k].r);
+								//vertices[k].i = R2ToI2( vertices[k].r);
 								vertices[k].ReferenceNumber=0;
 								vertices[k].DirOfSearch =NoDirOfSearch;
@@ -4529,5 +4529,5 @@
 									vertices[nbv].ReferenceNumber =0;
 									vertices[nbv].DirOfSearch =NoDirOfSearch;
-									//vertices[nbv].i = toI2(vertices[nbv].r);
+									//vertices[nbv].i = R2ToI2(vertices[nbv].r);
 									double a3[]={1./3.,1./3.,1./3.};
 									vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
@@ -4670,6 +4670,6 @@
 		for (int i=nbvold;i<nbv;i++) {// for all the new point
 			BamgVertex & vi = vertices[i];
-			vi.i = toI2(vi.r);
-			vi.r = toR2(vi.i);
+			vi.i = R2ToI2(vi.r);
+			vi.r = I2ToR2(vi.i);
 
 			// a good new point 
@@ -4703,10 +4703,10 @@
 /*}}}1*/
 /*FUNCTION Mesh::ToI2{{{1*/
-I2 Mesh::toI2(const R2 & P) const {
+I2 Mesh::R2ToI2(const R2 & P) const {
 	return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x)),(Icoor1) (coefIcoor*(P.y-pmin.y)) );
 }
 /*}}}1*/
 /*FUNCTION Mesh::ToR2{{{1*/
-R2 Mesh::toR2(const I2 & P) const {
+R2 Mesh::I2ToR2(const I2 & P) const {
 	return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
 }
Index: /issm/trunk/src/c/objects/Bamg/Mesh.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/Mesh.h	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/Mesh.h	(revision 5180)
@@ -74,6 +74,6 @@
 			double MinimalHmin();
 			double MaximalHmax();
-			I2 toI2(const R2 & P) const;
-			R2 toR2(const I2 & P) const;
+			I2 R2ToI2(const R2 & P) const;
+			R2 I2ToR2(const I2 & P) const;
 			void AddVertex(BamgVertex & s,Triangle * t,Icoor2 *  =0) ;
 			void Insert();
Index: /issm/trunk/src/c/objects/Bamg/QuadTree.cpp
===================================================================
--- /issm/trunk/src/c/objects/Bamg/QuadTree.cpp	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/QuadTree.cpp	(revision 5180)
@@ -79,7 +79,5 @@
 		th(NULL),                   // initial mesh = NULL
 		NbQuadTreeBox(0),           // initial number of quadtree boxes = 0
-		NbVertices(0),              // initial number of vertices = 0
-		NbQuadTreeBoxSearch(0),     // initial ?? = 0
-		NbVerticesSearch(0){        // initial ?? = 0
+		NbVertices(0){              // initial number of vertices = 0
 
 			//create lenStorageQuadTreeBox (100) StorageQuadTreeBox elements
@@ -98,7 +96,5 @@
 		th(t),
 		NbQuadTreeBox(0),
-		NbVertices(0),
-		NbQuadTreeBoxSearch(0),
-		NbVerticesSearch(0)
+		NbVertices(0)
 	{ 
 	 if (nbv == -1) nbv = t->nbv;
@@ -120,25 +116,4 @@
 	}
 	/*}}}1*/
-	/*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
-	QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long ll,StorageQuadTreeBox *nn) {
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/StorageQuadTreeBox)*/
-
-		/*Initilalize variables*/
-		len = ll;                  // number of quadtree boxes
-		n   = nn;                  // next StorageQuadTreeBox pointer
-		b   = new QuadTreeBox[ll]; // quadtree boxes 
-		ISSMASSERT(b);             // check allocation
-
-		/*Initialize all quadtree boxes (empty)*/
-		for (int i = 0; i <ll;i++){
-			b[i].n=0;
-			b[i].b[0]=b[i].b[1]=b[i].b[2]=b[i].b[3]=NULL;
-		}
-
-		bc = b;      //first quadtree box
-		be = b + ll; //last quadtree box
-
-	}
-	/*}}}1*/
 
 	/*Methods*/
@@ -160,8 +135,8 @@
 
 		//Find the smallest box where w is located
-		while((b=*pb) && (b->n<0)){ 
-
-			//shift b->n by -1
-			b->n--;
+		while((b=*pb) && (b->nbitems<0)){ 
+
+			//shift b->nbitems by -1
+			b->nbitems--;
 
 			//shifted righ by one bit: level=00000010 -> 00000001
@@ -175,8 +150,8 @@
 		//check that the vertex is not already in the box
 		if  (b) {      
-			if (b->n > 3 &&  b->v[3] == &w) return;
-			if (b->n > 2 &&  b->v[2] == &w) return;
-			if (b->n > 1 &&  b->v[1] == &w) return;
-			if (b->n > 0 &&  b->v[0] == &w) return;
+			if (b->nbitems > 3 &&  b->v[3] == &w) return;
+			if (b->nbitems > 2 &&  b->v[2] == &w) return;
+			if (b->nbitems > 1 &&  b->v[1] == &w) return;
+			if (b->nbitems > 0 &&  b->v[0] == &w) return;
 		}
 
@@ -188,5 +163,5 @@
 		//Now, try to add the vertex, if the subbox is full (n=4), we have to divide it
 		//in 4 new subboxes
-		while ((b= *pb) && (b->n == 4)){ // the QuadTreeBox is full
+		while ((b= *pb) && (b->nbitems == 4)){ // the QuadTreeBox is full
 
 			//Copy the 4 vertices in the current QuadTreebox
@@ -198,5 +173,5 @@
 
 			//set n as negative (box full -> holds 4 pointers toward subboxes and not 4 vertices)
-			b->n = -b->n;
+			b->nbitems = -b->nbitems;
 
 			//Initialize the 4 pointers toward the 4 subboxes
@@ -215,5 +190,5 @@
 
 				//Copy the 4 vertices
-				bb->v[bb->n++] = v4[k];
+				bb->v[bb->nbitems++] = v4[k];
 			}
 
@@ -226,5 +201,5 @@
 
 		//Add w
-		b->v[b->n++]=&w;
+		b->v[b->nbitems++]=&w;
 
 		//Increase NbVertices by one (we have one new vertex)
@@ -258,8 +233,8 @@
 
 		//if the tree is empty, return NULL pointer
-		if (!root->n) return vn; 
+		if (!root->nbitems) return vn; 
 
 		//else, find the non empty QuadTreeBox containing  the point (i,j)
-		while((n0=b->n)<0){
+		while((n0=b->nbitems)<0){
 
 			//shifted righ by one bit: hb2=01000000 -> 00100000
@@ -271,8 +246,7 @@
 
 			// break if NULL box or empty
-			if (( b0 == NULL) || (b0->n == 0)) break;
+			if (( b0 == NULL) || (b0->nbitems == 0)) break;
 
 			//Get next Qudtree box
-			NbQuadTreeBoxSearch++;
 			b=b0;	
 			i0 += I_IJ(k,hb2); // i orign of QuadTreeBox (macro)
@@ -291,5 +265,4 @@
 					vn = b->v[k];
 				}
-				NbVerticesSearch++;
 			}
 			return vn;
@@ -301,5 +274,5 @@
 		//initialize pb pi ii and jj
 		pb[0]=b;                  //pointer toward the box b
-		pi[0]=b->n>0? (int)b->n:4;//number of vertices in the box
+		pi[0]=b->nbitems>0? (int)b->nbitems:4;//number of vertices in the box
 		ii[0]=i0;                 // i coordinate of the box
 		jj[0]=j0;                 // j coordinate of the box
@@ -321,6 +294,5 @@
 
 				//if the current subbox is holding vertices,
-				if (b->n>0){ // BamgVertex QuadTreeBox not empty
-					NbVerticesSearch++;
+				if (b->nbitems>0){ // BamgVertex QuadTreeBox not empty
 					I2 i2 =  b->v[k]->i;
 					h0 = NORM(iplus,i2.x,jplus,i2.y);
@@ -333,5 +305,4 @@
 				else{
 					register QuadTreeBox* b0=b;
-					NbQuadTreeBoxSearch++;
 
 					//if the next box exists:
@@ -345,5 +316,5 @@
 						if (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h)){
 							pb[++level]=  b;
-							pi[level]= b->n>0 ?(int)  b->n : 4  ;
+							pi[level]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
 							ii[level]= iii;
 							jj[level]= jjj;
@@ -391,8 +362,8 @@
 		b = root;
 		register long  n0;
-		if (!root->n)
+		if (!root->nbitems)
 		 return vn; // empty tree 
 
-		while( (n0 = b->n) < 0) 
+		while( (n0 = b->nbitems) < 0) 
 		  {
 			// search the non empty 
@@ -401,7 +372,6 @@
 			register  int k = IJ(iplus,jplus,hb2);// QuadTreeBox number of size hb2 contening i;j
 			register QuadTreeBox * b0= b->b[k];
-			if ( ( b0 == 0) || (b0->n == 0) ) 
+			if ( ( b0 == 0) || (b0->nbitems == 0) ) 
 			 break; // null box or empty   => break 	    
-			NbQuadTreeBoxSearch++;
 			b=b0;	
 			i0 += I_IJ(k,hb2); // i orign of QuadTreeBox
@@ -421,5 +391,4 @@
 					h = h0;
 					vn = b->v[k];}
-					NbVerticesSearch++;
 			  }
 			if (vn) return vn; 
@@ -429,5 +398,5 @@
 		l =0; // level 
 		pb[0]= b;
-		pi[0]=b->n>0 ?(int)  b->n : 4  ;
+		pi[0]=b->nbitems>0 ?(int)  b->nbitems : 4  ;
 		ii[0]=i0;
 		jj[0]=j0;
@@ -439,7 +408,6 @@
 				int k = pi[l];
 
-				if (b->n>0) // BamgVertex QuadTreeBox none empty
+				if (b->nbitems>0) // BamgVertex QuadTreeBox none empty
 				  { 
-					NbVerticesSearch++;
 					I2 i2 =  b->v[k]->i;
 					// if good direction when try -- 
@@ -455,5 +423,4 @@
 				  { 
 					register QuadTreeBox *b0=b;
-					NbQuadTreeBoxSearch++;
 					if ((b=b->b[k])) 
 					  {
@@ -465,5 +432,5 @@
 						  {
 							pb[++l]=  b;
-							pi[l]= b->n>0 ?(int)  b->n : 4  ;
+							pi[l]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
 							ii[l]= iii;
 							jj[l]= jjj;
@@ -483,4 +450,20 @@
 	}
 	/*}}}1*/
+	/*FUNCTION QuadTree::NewQuadTreeBox {{{1*/
+	QuadTree::QuadTreeBox* QuadTree::NewQuadTreeBox(void){
+
+		/*if firstbox==lastbox or firstbox>lastbox (we have reach the end of the StorageQuadTreeBox)
+		 * create a new StorageQuadTreeBox)*/
+		if(!(sb->firstbox<sb->lastbox)){
+			sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
+		}
+		ISSMASSERT(sb && sb->firstbox->nbitems==0);
+
+		/*Increase counter*/
+		NbQuadTreeBox++;
+
+		/*firstbox now points toward next quadtree box*/
+		return sb->firstbox++;
+	}/*}}}*/
 	/*FUNCTION QuadTree::SizeOf{{{1*/
 	long QuadTree::SizeOf() const {
@@ -508,10 +491,10 @@
 		//  BamgVertex *vn=0;
 
-		if (!root->n)
+		if (!root->nbitems)
 		 return 0; // empty tree 
 
 		// general case -----
 		pb[0]=root;
-		pi[0]=root->n>0 ?(int)  root->n : 4  ;
+		pi[0]=root->nbitems>0 ?(int)  root->nbitems : 4  ;
 		ii[0]=i0;
 		jj[0]=j0;
@@ -523,7 +506,6 @@
 				register int k = pi[l];
 
-				if (b->n>0) // BamgVertex QuadTreeBox none empty
+				if (b->nbitems>0) // BamgVertex QuadTreeBox none empty
 				  { 
-					NbVerticesSearch++;
 					I2 i2 =  b->v[k]->i;
 					if ( ABS(i-i2.x) <hx && ABS(j-i2.y) <hy )
@@ -539,5 +521,4 @@
 				  { 
 					register QuadTreeBox *b0=b;
-					NbQuadTreeBoxSearch++;
 					if ((b=b->b[k]))
 					  {
@@ -549,5 +530,5 @@
 						  {
 							pb[++l]=  b;
-							pi[l]= b->n>0 ?(int)  b->n : 4  ;
+							pi[l]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
 							ii[l]= iii;
 							jj[l]= jjj;
@@ -568,3 +549,42 @@
 	/*}}}1*/
 
+	/*StorageQuadTreeBox Methods*/
+	/*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
+	QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long nbquadtreeboxes_in,StorageQuadTreeBox *nextsb_in) {
+		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/StorageQuadTreeBox)*/
+
+		/*Initilalize variables*/
+		nbquadtreeboxes = nbquadtreeboxes_in;       // number of quadtree boxes
+		nextsb          = nextsb_in;                // next StorageQuadTreeBox pointer
+		boxes   = new QuadTreeBox[nbquadtreeboxes]; // quadtree boxes 
+		ISSMASSERT(boxes);                          // check allocation
+
+		/*Initialize all quadtree boxes (empty)*/
+		for (int i = 0; i <nbquadtreeboxes;i++){
+			boxes[i].nbitems=0;
+			boxes[i].b[0]=NULL;
+			boxes[i].b[1]=NULL;
+			boxes[i].b[2]=NULL;
+			boxes[i].b[3]=NULL;
+		}
+
+		firstbox = boxes;
+		lastbox  = boxes + nbquadtreeboxes;
+
+	}
+	/*}}}1*/
+	/*FUNCTION QuadTree::StorageQuadTreeBox::~StorageQuadTreeBox{{{1*/
+	QuadTree::StorageQuadTreeBox::~StorageQuadTreeBox(){
+
+		if(nextsb) delete nextsb;
+		delete [] boxes;
+
+	}
+	/*}}}1*/
+	/*FUNCTION QuadTree::StorageQuadTreeBox::SizeOf {{{1*/
+	long  QuadTree::StorageQuadTreeBox::SizeOf() const {
+
+		return nbquadtreeboxes*sizeof(QuadTreeBox)+sizeof(StorageQuadTreeBox)+ (nextsb?nextsb->SizeOf():0);
+
+	}/*}}}*/
 }
Index: /issm/trunk/src/c/objects/Bamg/QuadTree.h
===================================================================
--- /issm/trunk/src/c/objects/Bamg/QuadTree.h	(revision 5179)
+++ /issm/trunk/src/c/objects/Bamg/QuadTree.h	(revision 5180)
@@ -26,5 +26,5 @@
 				public:
 
-					int n; // number of current vertices in the box
+					int nbitems; // number of current vertices in the box
 
 					union{
@@ -39,15 +39,12 @@
 
 					/*Fields*/
-					QuadTreeBox *b,*bc,*be;
-					long len;
-					StorageQuadTreeBox* n; // next StorageQuadTreeBox
+					QuadTreeBox        *boxes,*firstbox,*lastbox;
+					long                nbquadtreeboxes;
+					StorageQuadTreeBox *nextsb;         // next StorageQuadTreeBox
 
 					/*Methods*/
 					StorageQuadTreeBox(long ,StorageQuadTreeBox* =NULL);
-					~StorageQuadTreeBox() {
-						if(n) delete n;
-						delete [] b;
-					}
-					long  SizeOf() const {return len*sizeof(QuadTreeBox)+sizeof(StorageQuadTreeBox)+ (n?n->SizeOf():0);}
+					~StorageQuadTreeBox();
+					long  SizeOf() const;
 			};
 
@@ -61,34 +58,18 @@
 			QuadTreeBox* root;
 			Mesh*        th;
-			long         NbQuadTreeBox,NbVertices;
-			long         NbQuadTreeBoxSearch,NbVerticesSearch;
+			long         NbQuadTreeBox;
+			long         NbVertices;
 
+			QuadTree();
 			QuadTree(Mesh *t,long nbv=-1);
-			QuadTree();
 			~QuadTree();
-			BamgVertex* NearestVertex(Icoor1 i,Icoor1 j);
-			BamgVertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
-			BamgVertex* ToClose(BamgVertex & ,double ,Icoor1,Icoor1);
-			long    SizeOf() const;
-			void    Add( BamgVertex & w);
 
-			/*The following function cannot be in the cpp file because QuadTreeBox is
-			 * a private class and is declared before QuadTree::*/
-			QuadTreeBox* NewQuadTreeBox(void){
+			BamgVertex*  NearestVertex(Icoor1 i,Icoor1 j);
+			BamgVertex*  NearestVertexWithNormal(Icoor1 i,Icoor1 j);
+			QuadTreeBox* NewQuadTreeBox(void);
+			BamgVertex*  ToClose(BamgVertex & ,double ,Icoor1,Icoor1);
+			long         SizeOf() const;
+			void         Add( BamgVertex & w);
 
-				/*if bc==be or bc>be (we have reach the end of the StorageQuadTreeBox)
-				 * create a new StorageQuadTreeBox)*/
-				if(!(sb->bc<sb->be)){
-					sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
-				}
-				ISSMASSERT(sb && sb->bc->n==0);
-
-				/*Increase counter*/
-				NbQuadTreeBox++;
-
-				/*bc now points toward next quadtree box*/
-				return sb->bc++;
-
-			}
 	};
 }