Index: /issm/trunk/src/c/Bamgx/objects/BamgObjects.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/BamgObjects.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/BamgObjects.h	(revision 3407)
@@ -6,5 +6,5 @@
 #include "./DoubleAndInt.h"
 #include "./Direction.h"
-#include "./BamgVertex.h"
+#include "./MeshVertex.h"
 #include "./TriangleAdjacent.h"
 #include "./Edge.h"
Index: sm/trunk/src/c/Bamgx/objects/BamgVertex.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/BamgVertex.cpp	(revision 3406)
+++ 	(revision )
@@ -1,252 +1,0 @@
-#include <cstdio>
-#include <cstring>
-#include <cmath>
-#include <ctime>
-
-#include "BamgObjects.h"
-#include "../shared/shared.h"
-
-namespace bamg {
-
-	/*Methods*/
-	/*FUNCTION Vertex::Smoothing{{{1*/
-	double  Vertex::Smoothing(Triangles &Th,const Triangles &BTh,Triangle* &tstart ,double omega){
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Smoothing)*/
-
-		register Vertex* s=this;
-		Vertex &vP = *s,vPsave=vP;
-
-		register Triangle* tbegin= t , *tria = t , *ttc;
-
-		register int k=0,kk=0,j = EdgesVertexTriangle[vint][0],jc;
-		R2 P(s->r),PNew(0,0);
-		do {
-			k++; 
-
-			if (!tria->Hidden(j)){
-				Vertex &vQ = (*tria)[VerticesOfTriangularEdge[j][0]]; 
-
-				R2 Q = vQ,QP(P-Q);
-				double lQP = LengthInterpole(vP,vQ,QP);
-				PNew += Q+QP/Max(lQP,1e-20);
-				kk ++;
-			}
-			ttc =  tria->TriangleAdj(j);
-			jc = NextEdge[tria->NuEdgeTriangleAdj(j)];
-			tria = ttc;
-			j = NextEdge[jc];
-			if (k>=2000){
-				ISSMERROR(exprintf("k>=2000 (Maximum number of iterations reached)"));
-			}
-		} while ( tbegin != tria); 
-		if (kk<4) return 0;
-		PNew = PNew/(double)kk;
-		R2 Xmove((PNew-P)*omega);
-		PNew = P+Xmove;
-		double delta=Norme2_2(Xmove); 
-
-		Icoor2 deta[3];
-		I2 IBTh  = BTh.toI2(PNew);
-
-		tstart=BTh.FindTriangleContaining(IBTh,deta,tstart);  
-
-		if (tstart->det <0){ // outside
-			double ba,bb;
-			TriangleAdjacent edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
-			tstart = edge;
-			vP.m= Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));
-		}
-		else { // inside
-			double   aa[3];
-			double s = deta[0]+deta[1]+deta[2];
-			aa[0]=deta[0]/s;
-			aa[1]=deta[1]/s;
-			aa[2]=deta[2]/s;
-			vP.m = Metric(aa,(*tstart)[0],(*tstart)[1],(*tstart)[2]);
-		}
-
-		// recompute the det of the triangle
-		vP.r = PNew;
-
-		vP.i = Th.toI2(PNew);
-
-		Vertex vPnew = vP;
-
-		int ok=1;
-		int loop=1;
-		k=0;
-		while (ok){
-			ok =0;
-			do {
-				k++; 
-				double detold = tria->det;
-				tria->det =  bamg::det( (*tria)[0],(*tria)[1]  ,(*tria)[2]);
-				if (loop) {
-					Vertex *v0,*v1,*v2,*v3;
-					if (tria->det<0) ok =1;			       
-					else if (tria->Quadrangle(v0,v1,v2,v3))
-					  {
-						vP = vPsave;
-						double qold =QuadQuality(*v0,*v1,*v2,*v3);
-						vP = vPnew;
-						double qnew =QuadQuality(*v0,*v1,*v2,*v3);
-						if (qnew<qold) ok = 1;
-					  }
-					else if ( (double)tria->det < detold/2 ) ok=1;
-
-				}
-				tria->SetUnMarkUnSwap(0);
-				tria->SetUnMarkUnSwap(1);
-				tria->SetUnMarkUnSwap(2);
-				ttc =  tria->TriangleAdj(j);
-				jc = NextEdge[tria->NuEdgeTriangleAdj(j)];
-				tria = ttc;
-				j = NextEdge[jc];
-				if (k>=2000){
-					ISSMERROR(exprintf("k>=2000"));
-				}
-			}while ( tbegin != tria); 
-
-			if (ok && loop) vP=vPsave; // no move 
-			loop=0;
-		}
-		return delta;
-	}
-	/*}}}1*/
-	/*FUNCTION Vertex::MetricFromHessian{{{1*/
-	void Vertex::MetricFromHessian(const double Hxx,const double Hyx, const double Hyy,const double smin,const double smax,const double s,double err,BamgOpts* bamgopts){
-		/*Compute Metric from Hessian*/
-
-		/*get options*/
-		double power=(bamgopts->power);
-		double anisomax=(bamgopts->anisomax);
-		double CutOff=bamgopts->cutoff;
-		double hmin=(bamgopts->hmin);
-		double hmax=(bamgopts->hmax);
-		double coef=bamgopts->coef;
-		int    Metrictype=(bamgopts->Metrictype);
-
-		/*Intermediary*/
-		double ci;
-
-		/*compute multiplicative coefficient depending on Metric Type (2/9 because it is 2d)*/
-
-		//Absolute Error
-		/*
-		 *            2         1       
-		 *Metric M = ---  ------------   Abs(Hessian)
-		 *            9   err * coeff^2  
-		 */
-		if (Metrictype==0){
-			ci= 2.0/9.0 * 1/(err*coef*coef);
-		}
-
-		//Relative Error
-		/*
-		 *            2         1            Abs(Hessian)
-		 *Metric M = ---  ------------  ----------------------
-		 *            9   err * coeff^2  max( |s| , cutoff*max(|s|) )
-		 *
-		 */
-		else if (Metrictype==1){
-			ci= 2.0/9.0 * 1/(err*coef*coef) * 1/Max( Abs(s), CutOff*(Max(Abs(smin),Abs(smax))));
-		}
-
-		//Rescaled absolute error
-		/*
-		 *            2         1            Abs(Hessian)
-		 *Metric M = ---  ------------  ---------------------- 
-		 *            9   err * coeff^2       (smax-smin)
-		 */
-		else if (Metrictype==2){
-			ci= 2.0/9.0 * 1/(err*coef*coef) * 1/(smax-smin);
-		}
-		else{
-			ISSMERROR(exprintf("Metrictype %i not supported yet (use 0,1 or 2(default))",Metrictype));
-		}
-
-		//initialize metric Miv with ci*H
-		Metric Miv(Hxx*ci,Hyx*ci,Hyy*ci);
-
-		//Get eigen values and vectors of Miv
-		MatVVP2x2 Vp(Miv);
-
-		//move eigen valuse to their absolute values
-		Vp.Abs();
-
-		//Apply a power if requested by user
-		if(power!=1.0) Vp.pow(power);
-
-		//modify eigen values according to hmin and hmax
-		Vp.Maxh(hmax);
-		Vp.Minh(hmin);
-
-		//Bound anisotropy by 1/(anisomax)^2
-		Vp.BoundAniso2(1/(anisomax*anisomax));
-
-		//rebuild Metric from Vp
-		Metric MVp(Vp);
-
-		//Apply Metric to vertex
-		m.IntersectWith(MVp);
-
-	}
-	/*}}}1*/
-	/*FUNCTION Vertex::Echo {{{1*/
-
-	void Vertex::Echo(void){
-
-		printf("Vertex:\n");
-		printf("  integer   coordinates i.x: %i, i.y: %i\n",i.x,i.y);
-		printf("  Euclidean coordinates r.x: %g, r.y: %g\n",r.x,r.y);
-		printf("  ReferenceNumber = %i\n",ReferenceNumber);
-		m.Echo();
-
-		return;
-	}
-	/*}}}*/
-	/*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*/
-	/*FUNCTION QuadQuality{{{1*/
-	double QuadQuality(const Vertex & a,const Vertex &b,const Vertex &c,const Vertex &d) {
-		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/QuadQuality)*/
-
-		// calcul de 4 angles --
-		R2 A((R2)a),B((R2)b),C((R2)c),D((R2)d);
-		R2 AB(B-A),BC(C-B),CD(D-C),DA(A-D);
-		//  Move(A),Line(B),Line(C),Line(D),Line(A);
-		const Metric & Ma  = a;
-		const Metric & Mb  = b;
-		const Metric & Mc  = c;
-		const Metric & Md  = d;
-
-		double lAB=Norme2(AB);
-		double lBC=Norme2(BC);
-		double lCD=Norme2(CD);
-		double lDA=Norme2(DA);
-		AB /= lAB;  BC /= lBC;  CD /= lCD;  DA /= lDA;
-		// version aniso 
-		double cosDAB= Ma(DA,AB)/(Ma(DA)*Ma(AB)),sinDAB= Det(DA,AB);
-		double cosABC= Mb(AB,BC)/(Mb(AB)*Mb(BC)),sinABC= Det(AB,BC);
-		double cosBCD= Mc(BC,CD)/(Mc(BC)*Mc(CD)),sinBCD= Det(BC,CD);
-		double cosCDA= Md(CD,DA)/(Md(CD)*Md(DA)),sinCDA= Det(CD,DA);
-		double sinmin=Min(Min(sinDAB,sinABC),Min(sinBCD,sinCDA));
-		if (sinmin<=0) return sinmin;
-		return 1.0-Max(Max(Abs(cosDAB),Abs(cosABC)),Max(Abs(cosBCD),Abs(cosCDA)));
-	}
-	/*}}}1*/
-
-} 
Index: sm/trunk/src/c/Bamgx/objects/BamgVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/BamgVertex.h	(revision 3406)
+++ 	(revision )
@@ -1,60 +1,0 @@
-#ifndef _VERTEX_H_
-#define _VERTEX_H_
-
-#include "../../objects/objects.h"
-#include "../../shared/shared.h"
-#include "../../include/macros.h"
-#include "../../toolkits/toolkits.h"
-
-#include "../include/typedefs.h"
-#include "../include/macros.h"
-#include "Direction.h"
-#include "Metric.h"
-
-namespace bamg {
-
-	//classes
-	class Triangle;
-	class Triangles;
-	class VertexOnGeom;
-	class VertexOnEdge;
-
-	class Vertex {
-
-		public:
-			I2 i;  // integer coordinates
-			R2 r;  // real coordinates
-			Metric m;
-			long ReferenceNumber;
-			Direction DirOfSearch;
-			short vint;  // the vertex number in triangle; varies between 0 and 2 in t
-			union {
-				Triangle* t;   // one triangle which is containing the vertex
-				long      color;
-				Vertex*   to;  // used in geometry Vertex to know the Mesh Vertex associated 
-				VertexOnGeom* onGeometry;        // if vint == 8; // set with Triangles::SetVertexFieldOn()
-				Vertex*       onBackgroundVertex;// if vint == 16 on Background vertex Triangles::SetVertexFieldOnBTh()
-				VertexOnEdge* onBackgroundEdge;  // if vint == 32 on Background edge
-			};
-
-			//Operators
-			operator I2() const {return i;}             // Cast operator
-			operator const R2 & () const {return r;}    // Cast operator
-			operator Metric () const {return m;}        // Cast operator
-			double operator()(R2 x) const { return m(x);} // Get x in the metric m
-
-			//methods (No constructor and no destructors...)
-			double Smoothing(Triangles & ,const Triangles & ,Triangle  * & ,double =1);
-			void   MetricFromHessian(const double Hxx,const double Hyx, const double Hyy, const double smin,const double smax,const double s,const double err,BamgOpts* bamgopts);
-			void   Echo();
-			int    ref() const { return ReferenceNumber;}
-			long   Optim(int =1,int =0); 
-
-			//inline functions
-			inline void Set(const Vertex &rec,const Triangles & ,Triangles & ){*this=rec;}
-	};
-
-	//Intermediary
-	double QuadQuality(const Vertex &,const Vertex &,const Vertex &,const Vertex &);
-}
-#endif
Index: /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/CrackedEdge.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "TriangleAdjacent.h"
 #include "Edge.h"
Index: /issm/trunk/src/c/Bamgx/objects/Edge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Edge.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Edge.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "TriangleAdjacent.h"
 
@@ -21,5 +21,5 @@
 
 		public:
-			Vertex* v[2];
+			MeshVertex* v[2];
 			long ref;
 			GeometricalEdge* onGeometry;
@@ -27,11 +27,11 @@
 
 			//Operators
-			Vertex & operator[](int i){return *v[i];};
-			Vertex * operator()(int i){return v[i];};
+			MeshVertex & operator[](int i){return *v[i];};
+			MeshVertex * operator()(int i){return v[i];};
 			R2       operator()(double t) const; // return the point 
-			const Vertex & operator[](int i) const { return *v[i];};
+			const MeshVertex & operator[](int i) const { return *v[i];};
 
 			//Methods
-			void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
+			void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){
 				if (v[0] >=vb && v[0] <ve) v[0] = vb + renu[v[0]-vb];
 				if (v[1] >=vb && v[1] <ve) v[1] = vb + renu[v[1]-vb];
Index: /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 
 namespace bamg {
@@ -16,5 +16,5 @@
 	class Geometry;
 
-	class GeometricalVertex : public Vertex { 
+	class GeometricalVertex : public MeshVertex { 
 
 		public:
Index: /issm/trunk/src/c/Bamgx/objects/Geometry.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Geometry.cpp	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Geometry.cpp	(revision 3407)
@@ -120,5 +120,5 @@
 		}
 		else{
-			ISSMERROR(exprintf("No Vertex provided"));
+			ISSMERROR(exprintf("No MeshVertex provided"));
 		}
 
@@ -438,5 +438,5 @@
 		double eps=1e-20;
 		QuadTree quadtree; // build quadtree to find duplicates
-		Vertex* v0=vertices; 
+		MeshVertex* v0=vertices; 
 		GeometricalVertex* v0g=(GeometricalVertex*) (void*)v0;   
 
@@ -457,5 +457,5 @@
 
 			//find nearest vertex already present in the quadtree (NULL if empty)
-			Vertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y); 
+			MeshVertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y); 
 
 			//if there is a vertex found that is to close to vertices[i] -> error
@@ -465,6 +465,6 @@
 				j=vg-v0g;
 				//check that the clostest vertex is not itself...
-				if ( v !=  &(Vertex &) vertices[j]){
-					ISSMERROR(exprintf(" v !=  &(Vertex &) vertices[j]"));
+				if ( v !=  &(MeshVertex &) vertices[j]){
+					ISSMERROR(exprintf(" v !=  &(MeshVertex &) vertices[j]"));
 				}
 				vertices[i].link = vertices + j;
@@ -830,5 +830,5 @@
 	/*}}}1*/
 	/*FUNCTION  Geometry::ProjectOnCurve {{{1*/
-	GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s,Vertex &V,VertexOnGeom &GV) const {
+	GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s,MeshVertex &V,VertexOnGeom &GV) const {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/
 		/*Add a vertex on an existing geometrical edge according to the metrics of the two vertices constituting the edge*/
@@ -849,6 +849,6 @@
 
 		//Get the two vertices of the edge
-		const Vertex &v0=e[0];
-		const Vertex &v1=e[1];
+		const MeshVertex &v0=e[0];
+		const MeshVertex &v1=e[1];
 
 		//Get position of V0, V1 and vector v0->v1
@@ -916,8 +916,8 @@
 
 		if ((*eg0)(sens0)==(GeometricalVertex*)vg0)
-		 vg0=VertexOnGeom(*(Vertex*) vg0,*eg0,sens0); //vg0 = absisce
+		 vg0=VertexOnGeom(*(MeshVertex*) vg0,*eg0,sens0); //vg0 = absisce
 
 		if ((*eg1)(sens1)==(GeometricalVertex*)vg1)
-		 vg1=VertexOnGeom(*(Vertex*) vg1,*eg1,sens1);
+		 vg1=VertexOnGeom(*(MeshVertex*) vg1,*eg1,sens1);
 
 		double sg;
Index: /issm/trunk/src/c/Bamgx/objects/Geometry.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Geometry.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Geometry.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "Edge.h"
 #include "GeometricalVertex.h"
@@ -70,5 +70,5 @@
 			long Number(const Curve * c) const  { return c - curves;}
 			void UnMarkEdges() {for (int i=0;i<nbe;i++) edges[i].SetUnMark();}
-			GeometricalEdge *  ProjectOnCurve(const Edge & ,double,Vertex &,VertexOnGeom &) const ;
+			GeometricalEdge *  ProjectOnCurve(const Edge & ,double,MeshVertex &,VertexOnGeom &) const ;
 			GeometricalEdge *  Containing(const R2 P,  GeometricalEdge * start) const;
 			void WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts);
Index: /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp	(revision 3407)
@@ -45,5 +45,5 @@
 				double ba,bb;
 				TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
-				Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
+				MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 				NewItem(A,Metric(ba,v0,bb,v1));
 				t=edge;
@@ -51,5 +51,5 @@
 				if (det(v0.i,v1.i,b)>=0) {
 					TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
-					Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
+					MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 					NewItem(A,Metric(ba,v0,bb,v1));
 					return;
@@ -81,5 +81,5 @@
 					long int verbosity=2;
 					TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
-					Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
+					MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
 					NewItem(A,Metric(ba,v0,bb,v1));
 					return;
@@ -233,5 +233,5 @@
 			lIntTria[Size].x = x;
 			Metric m0,m1,m2;
-			register Vertex * v;
+			register MeshVertex * v;
 			if ((v=(*tt)(0))) m0    = v->m;
 			if ((v=(*tt)(1))) m1    = v->m;
@@ -308,5 +308,5 @@
 	/*}}}1*/
 	/*FUNCTION ListofIntersectionTriangles::NewPoints{{{1*/
-	long ListofIntersectionTriangles::NewPoints(Vertex* vertices,long &nbv,long nbvx){
+	long ListofIntersectionTriangles::NewPoints(MeshVertex* vertices,long &nbv,long nbvx){
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
 
Index: /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.h	(revision 3407)
@@ -10,5 +10,5 @@
 #include "../include/macros.h"
 #include "Metric.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "Edge.h"
 #include "GeometricalEdge.h"
@@ -82,5 +82,5 @@
 			void  SplitEdge(const Triangles & ,const R2 &,const R2  &,int nbegin=0); 
 			double Length(); 
-			long  NewPoints(Vertex *,long & nbv,long nbvx);
+			long  NewPoints(MeshVertex *,long & nbv,long nbvx);
 			void  NewSubSeg(GeometricalEdge *e,double s0,double s1){ 
 				long int verbosity=0;
Index: /issm/trunk/src/c/Bamgx/objects/MeshVertex.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/MeshVertex.cpp	(revision 3407)
+++ /issm/trunk/src/c/Bamgx/objects/MeshVertex.cpp	(revision 3407)
@@ -0,0 +1,252 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+
+#include "BamgObjects.h"
+#include "../shared/shared.h"
+
+namespace bamg {
+
+	/*Methods*/
+	/*FUNCTION MeshVertex::Smoothing{{{1*/
+	double  MeshVertex::Smoothing(Triangles &Th,const Triangles &BTh,Triangle* &tstart ,double omega){
+		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Smoothing)*/
+
+		register MeshVertex* s=this;
+		MeshVertex &vP = *s,vPsave=vP;
+
+		register Triangle* tbegin= t , *tria = t , *ttc;
+
+		register int k=0,kk=0,j = EdgesVertexTriangle[vint][0],jc;
+		R2 P(s->r),PNew(0,0);
+		do {
+			k++; 
+
+			if (!tria->Hidden(j)){
+				MeshVertex &vQ = (*tria)[VerticesOfTriangularEdge[j][0]]; 
+
+				R2 Q = vQ,QP(P-Q);
+				double lQP = LengthInterpole(vP,vQ,QP);
+				PNew += Q+QP/Max(lQP,1e-20);
+				kk ++;
+			}
+			ttc =  tria->TriangleAdj(j);
+			jc = NextEdge[tria->NuEdgeTriangleAdj(j)];
+			tria = ttc;
+			j = NextEdge[jc];
+			if (k>=2000){
+				ISSMERROR(exprintf("k>=2000 (Maximum number of iterations reached)"));
+			}
+		} while ( tbegin != tria); 
+		if (kk<4) return 0;
+		PNew = PNew/(double)kk;
+		R2 Xmove((PNew-P)*omega);
+		PNew = P+Xmove;
+		double delta=Norme2_2(Xmove); 
+
+		Icoor2 deta[3];
+		I2 IBTh  = BTh.toI2(PNew);
+
+		tstart=BTh.FindTriangleContaining(IBTh,deta,tstart);  
+
+		if (tstart->det <0){ // outside
+			double ba,bb;
+			TriangleAdjacent edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
+			tstart = edge;
+			vP.m= Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));
+		}
+		else { // inside
+			double   aa[3];
+			double s = deta[0]+deta[1]+deta[2];
+			aa[0]=deta[0]/s;
+			aa[1]=deta[1]/s;
+			aa[2]=deta[2]/s;
+			vP.m = Metric(aa,(*tstart)[0],(*tstart)[1],(*tstart)[2]);
+		}
+
+		// recompute the det of the triangle
+		vP.r = PNew;
+
+		vP.i = Th.toI2(PNew);
+
+		MeshVertex vPnew = vP;
+
+		int ok=1;
+		int loop=1;
+		k=0;
+		while (ok){
+			ok =0;
+			do {
+				k++; 
+				double detold = tria->det;
+				tria->det =  bamg::det( (*tria)[0],(*tria)[1]  ,(*tria)[2]);
+				if (loop) {
+					MeshVertex *v0,*v1,*v2,*v3;
+					if (tria->det<0) ok =1;			       
+					else if (tria->Quadrangle(v0,v1,v2,v3))
+					  {
+						vP = vPsave;
+						double qold =QuadQuality(*v0,*v1,*v2,*v3);
+						vP = vPnew;
+						double qnew =QuadQuality(*v0,*v1,*v2,*v3);
+						if (qnew<qold) ok = 1;
+					  }
+					else if ( (double)tria->det < detold/2 ) ok=1;
+
+				}
+				tria->SetUnMarkUnSwap(0);
+				tria->SetUnMarkUnSwap(1);
+				tria->SetUnMarkUnSwap(2);
+				ttc =  tria->TriangleAdj(j);
+				jc = NextEdge[tria->NuEdgeTriangleAdj(j)];
+				tria = ttc;
+				j = NextEdge[jc];
+				if (k>=2000){
+					ISSMERROR(exprintf("k>=2000"));
+				}
+			}while ( tbegin != tria); 
+
+			if (ok && loop) vP=vPsave; // no move 
+			loop=0;
+		}
+		return delta;
+	}
+	/*}}}1*/
+	/*FUNCTION MeshVertex::MetricFromHessian{{{1*/
+	void MeshVertex::MetricFromHessian(const double Hxx,const double Hyx, const double Hyy,const double smin,const double smax,const double s,double err,BamgOpts* bamgopts){
+		/*Compute Metric from Hessian*/
+
+		/*get options*/
+		double power=(bamgopts->power);
+		double anisomax=(bamgopts->anisomax);
+		double CutOff=bamgopts->cutoff;
+		double hmin=(bamgopts->hmin);
+		double hmax=(bamgopts->hmax);
+		double coef=bamgopts->coef;
+		int    Metrictype=(bamgopts->Metrictype);
+
+		/*Intermediary*/
+		double ci;
+
+		/*compute multiplicative coefficient depending on Metric Type (2/9 because it is 2d)*/
+
+		//Absolute Error
+		/*
+		 *            2         1       
+		 *Metric M = ---  ------------   Abs(Hessian)
+		 *            9   err * coeff^2  
+		 */
+		if (Metrictype==0){
+			ci= 2.0/9.0 * 1/(err*coef*coef);
+		}
+
+		//Relative Error
+		/*
+		 *            2         1            Abs(Hessian)
+		 *Metric M = ---  ------------  ----------------------
+		 *            9   err * coeff^2  max( |s| , cutoff*max(|s|) )
+		 *
+		 */
+		else if (Metrictype==1){
+			ci= 2.0/9.0 * 1/(err*coef*coef) * 1/Max( Abs(s), CutOff*(Max(Abs(smin),Abs(smax))));
+		}
+
+		//Rescaled absolute error
+		/*
+		 *            2         1            Abs(Hessian)
+		 *Metric M = ---  ------------  ---------------------- 
+		 *            9   err * coeff^2       (smax-smin)
+		 */
+		else if (Metrictype==2){
+			ci= 2.0/9.0 * 1/(err*coef*coef) * 1/(smax-smin);
+		}
+		else{
+			ISSMERROR(exprintf("Metrictype %i not supported yet (use 0,1 or 2(default))",Metrictype));
+		}
+
+		//initialize metric Miv with ci*H
+		Metric Miv(Hxx*ci,Hyx*ci,Hyy*ci);
+
+		//Get eigen values and vectors of Miv
+		MatVVP2x2 Vp(Miv);
+
+		//move eigen valuse to their absolute values
+		Vp.Abs();
+
+		//Apply a power if requested by user
+		if(power!=1.0) Vp.pow(power);
+
+		//modify eigen values according to hmin and hmax
+		Vp.Maxh(hmax);
+		Vp.Minh(hmin);
+
+		//Bound anisotropy by 1/(anisomax)^2
+		Vp.BoundAniso2(1/(anisomax*anisomax));
+
+		//rebuild Metric from Vp
+		Metric MVp(Vp);
+
+		//Apply Metric to vertex
+		m.IntersectWith(MVp);
+
+	}
+	/*}}}1*/
+	/*FUNCTION MeshVertex::Echo {{{1*/
+
+	void MeshVertex::Echo(void){
+
+		printf("Vertex:\n");
+		printf("  integer   coordinates i.x: %i, i.y: %i\n",i.x,i.y);
+		printf("  Euclidean coordinates r.x: %g, r.y: %g\n",r.x,r.y);
+		printf("  ReferenceNumber = %i\n",ReferenceNumber);
+		m.Echo();
+
+		return;
+	}
+	/*}}}*/
+	/*FUNCTION MeshVertex::Optim {{{1*/
+	long MeshVertex::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*/
+	/*FUNCTION QuadQuality{{{1*/
+	double QuadQuality(const MeshVertex & a,const MeshVertex &b,const MeshVertex &c,const MeshVertex &d) {
+		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/QuadQuality)*/
+
+		// calcul de 4 angles --
+		R2 A((R2)a),B((R2)b),C((R2)c),D((R2)d);
+		R2 AB(B-A),BC(C-B),CD(D-C),DA(A-D);
+		//  Move(A),Line(B),Line(C),Line(D),Line(A);
+		const Metric & Ma  = a;
+		const Metric & Mb  = b;
+		const Metric & Mc  = c;
+		const Metric & Md  = d;
+
+		double lAB=Norme2(AB);
+		double lBC=Norme2(BC);
+		double lCD=Norme2(CD);
+		double lDA=Norme2(DA);
+		AB /= lAB;  BC /= lBC;  CD /= lCD;  DA /= lDA;
+		// version aniso 
+		double cosDAB= Ma(DA,AB)/(Ma(DA)*Ma(AB)),sinDAB= Det(DA,AB);
+		double cosABC= Mb(AB,BC)/(Mb(AB)*Mb(BC)),sinABC= Det(AB,BC);
+		double cosBCD= Mc(BC,CD)/(Mc(BC)*Mc(CD)),sinBCD= Det(BC,CD);
+		double cosCDA= Md(CD,DA)/(Md(CD)*Md(DA)),sinCDA= Det(CD,DA);
+		double sinmin=Min(Min(sinDAB,sinABC),Min(sinBCD,sinCDA));
+		if (sinmin<=0) return sinmin;
+		return 1.0-Max(Max(Abs(cosDAB),Abs(cosABC)),Max(Abs(cosBCD),Abs(cosCDA)));
+	}
+	/*}}}1*/
+
+} 
Index: /issm/trunk/src/c/Bamgx/objects/MeshVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/MeshVertex.h	(revision 3407)
+++ /issm/trunk/src/c/Bamgx/objects/MeshVertex.h	(revision 3407)
@@ -0,0 +1,60 @@
+#ifndef _VERTEX_H_
+#define _VERTEX_H_
+
+#include "../../objects/objects.h"
+#include "../../shared/shared.h"
+#include "../../include/macros.h"
+#include "../../toolkits/toolkits.h"
+
+#include "../include/typedefs.h"
+#include "../include/macros.h"
+#include "Direction.h"
+#include "Metric.h"
+
+namespace bamg {
+
+	//classes
+	class Triangle;
+	class Triangles;
+	class VertexOnGeom;
+	class VertexOnEdge;
+
+	class MeshVertex {
+
+		public:
+			I2 i;  // integer coordinates
+			R2 r;  // real coordinates
+			Metric m;
+			long ReferenceNumber;
+			Direction DirOfSearch;
+			short vint;  // the vertex number in triangle; varies between 0 and 2 in t
+			union {
+				Triangle* t;   // one triangle which is containing the vertex
+				long      color;
+				MeshVertex*   to;  // used in geometry MeshVertex to know the Mesh MeshVertex associated 
+				VertexOnGeom* onGeometry;        // if vint == 8; // set with Triangles::SetVertexFieldOn()
+				MeshVertex*       onBackgroundVertex;// if vint == 16 on Background vertex Triangles::SetVertexFieldOnBTh()
+				VertexOnEdge* onBackgroundEdge;  // if vint == 32 on Background edge
+			};
+
+			//Operators
+			operator I2() const {return i;}             // Cast operator
+			operator const R2 & () const {return r;}    // Cast operator
+			operator Metric () const {return m;}        // Cast operator
+			double operator()(R2 x) const { return m(x);} // Get x in the metric m
+
+			//methods (No constructor and no destructors...)
+			double Smoothing(Triangles & ,const Triangles & ,Triangle  * & ,double =1);
+			void   MetricFromHessian(const double Hxx,const double Hyx, const double Hyy, const double smin,const double smax,const double s,const double err,BamgOpts* bamgopts);
+			void   Echo();
+			int    ref() const { return ReferenceNumber;}
+			long   Optim(int =1,int =0); 
+
+			//inline functions
+			inline void Set(const MeshVertex &rec,const Triangles & ,Triangles & ){*this=rec;}
+	};
+
+	//Intermediary
+	double QuadQuality(const MeshVertex &,const MeshVertex &,const MeshVertex &,const MeshVertex &);
+}
+#endif
Index: /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/QuadTree.cpp	(revision 3407)
@@ -121,5 +121,5 @@
 	/*Methods*/
 	/*FUNCTION QuadTree::Add{{{1*/
-	void  QuadTree::Add(Vertex &w){
+	void  QuadTree::Add(MeshVertex &w){
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/Add)*/
 
@@ -164,5 +164,5 @@
 
 			//Copy the 4 vertices in the current QuadTreebox
-			Vertex* v4[4];
+			MeshVertex* v4[4];
 			v4[0]= b->v[0];
 			v4[1]= b->v[1];
@@ -206,5 +206,5 @@
 	/*}}}1*/
 	/*FUNCTION QuadTree::NearestVertex{{{1*/
-	Vertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
+	MeshVertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertex)*/
 
@@ -225,5 +225,5 @@
 		Icoor1   jplus( j<MaxISize?(j<0?0:j):MaxISize-1);
 		//initial nearest vertex pointer
-		Vertex*  vn=NULL;
+		MeshVertex*  vn=NULL;
 
 		//Get initial Quadtree box (largest)
@@ -294,5 +294,5 @@
 
 				//if the current subbox is holding vertices,
-				if (b->n>0){ // Vertex QuadTreeBox not empty
+				if (b->n>0){ // MeshVertex QuadTreeBox not empty
 					NbVerticesSearch++;
 					I2 i2 =  b->v[k]->i;
@@ -345,5 +345,5 @@
 	/*}}}1*/
 	/*FUNCTION QuadTree::NearestVertexWithNormal{{{1*/
-	Vertex*  QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {
+	MeshVertex*  QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertexWithNormal)*/
 
@@ -359,5 +359,5 @@
 		Icoor1  jplus( j<MaxISize?(j<0?0:j):MaxISize-1);
 
-		Vertex *vn=0;
+		MeshVertex *vn=0;
 
 		// init for optimisation ---
@@ -412,5 +412,5 @@
 				int k = pi[l];
 
-				if (b->n>0) // Vertex QuadTreeBox none empty
+				if (b->n>0) // MeshVertex QuadTreeBox none empty
 				  { 
 					NbVerticesSearch++;
@@ -473,5 +473,5 @@
 	/*}}}1*/
 	/*FUNCTION QuadTree::ToClose {{{1*/
-	Vertex *   QuadTree::ToClose(Vertex & v,double seuil,Icoor1 hx,Icoor1 hy){
+	MeshVertex *   QuadTree::ToClose(MeshVertex & v,double seuil,Icoor1 hx,Icoor1 hy){
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/ToClose)*/
 
@@ -490,5 +490,5 @@
 		Icoor1 i0=0,j0=0;
 
-		//  Vertex *vn=0;
+		//  MeshVertex *vn=0;
 
 		if (!root->n)
@@ -507,5 +507,5 @@
 				register int k = pi[l];
 
-				if (b->n>0) // Vertex QuadTreeBox none empty
+				if (b->n>0) // MeshVertex QuadTreeBox none empty
 				  { 
 					NbVerticesSearch++;
Index: /issm/trunk/src/c/Bamgx/objects/QuadTree.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/QuadTree.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/QuadTree.h	(revision 3407)
@@ -16,5 +16,5 @@
 
 	class Triangles;
-	class Vertex;
+	class MeshVertex;
 
 	class QuadTree{
@@ -23,9 +23,9 @@
 				public:
 					long n; 
-					//contains only one object form the list (either Vertex or QuadTreeBox)
-					// if n < 4 => Vertex else =>  QuadTreeBox;
+					//contains only one object form the list (either MeshVertex or QuadTreeBox)
+					// if n < 4 => MeshVertex else =>  QuadTreeBox;
 					union{
 						QuadTreeBox* b[4];
-						Vertex* v[4];
+						MeshVertex* v[4];
 					};
 			};
@@ -55,9 +55,9 @@
 			long    NbQuadTreeBox,NbVertices;
 			long    NbQuadTreeBoxSearch,NbVerticesSearch;
-			Vertex* NearestVertex(Icoor1 i,Icoor1 j);
-			Vertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
-			Vertex* ToClose(Vertex & ,double ,Icoor1,Icoor1);
+			MeshVertex* NearestVertex(Icoor1 i,Icoor1 j);
+			MeshVertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
+			MeshVertex* ToClose(MeshVertex & ,double ,Icoor1,Icoor1);
 			long    SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();}
-			void    Add( Vertex & w);
+			void    Add( MeshVertex & w);
 			QuadTreeBox* NewQuadTreeBox(){
 				if(! (sb->bc<sb->be)) sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
Index: /issm/trunk/src/c/Bamgx/objects/Triangle.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangle.cpp	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Triangle.cpp	(revision 3407)
@@ -12,5 +12,5 @@
 	/*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;
+		MeshVertex *v=Th->vertices;
 		long nbv = Th->nbv;
 		if (i<0 || j<0 || k<0){
@@ -28,6 +28,6 @@
 	}
 	/*}}}*/
-	/*FUNCTION Triangle(Vertex *v0,Vertex *v1,Vertex *v2) {{{1*/
-	Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
+	/*FUNCTION Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2) {{{1*/
+	Triangle::Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2){
 		TriaVertices[0]=v0;
 		TriaVertices[1]=v1;
@@ -155,5 +155,5 @@
 	/*}}}1*/
 	/*FUNCTION Triangle::Quadrangle {{{1*/
-	Triangle* Triangle::Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const{
+	Triangle* Triangle::Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const{
 		// return the other triangle of the quad if a quad or 0 if not a quat
 		Triangle * t =0;
@@ -187,8 +187,8 @@
 			 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]];
+				const MeshVertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
+				const MeshVertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
+				const MeshVertex & v1 = *TriaVertices[OppositeEdge[a]];
+				const MeshVertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
 				q =  QuadQuality(v0,v1,v2,v3); // do the float part
 			}
@@ -221,8 +221,8 @@
 		if(a2/4 !=0) return 0; // arete lock or MarkUnSwap
 
-		register Vertex  *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]];
-		register Vertex  *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]];
-		register Vertex  *s1=t1->TriaVertices[OppositeVertex[a1]];
-		register Vertex  *s2=t2->TriaVertices[OppositeVertex[a2]];
+		register MeshVertex  *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]];
+		register MeshVertex  *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]];
+		register MeshVertex  *s1=t1->TriaVertices[OppositeVertex[a1]];
+		register MeshVertex  *s2=t2->TriaVertices[OppositeVertex[a2]];
 
 		Icoor2 det1=t1->det , det2=t2->det ;
Index: /issm/trunk/src/c/Bamgx/objects/Triangle.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangle.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Triangle.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "TriangleAdjacent.h"
 
@@ -22,5 +22,5 @@
 
 		private:
-			Vertex*   TriaVertices[3];      // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
+			MeshVertex*   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
@@ -36,11 +36,11 @@
 			Triangle() {}
 			Triangle(Triangles *Th,long i,long j,long k);
-			Triangle(Vertex *v0,Vertex *v1,Vertex *v2);
+			Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2);
 
 			//Operators
-			const Vertex & operator[](int i) const {return *TriaVertices[i];};
-			Vertex & operator[](int i)  {return *TriaVertices[i];};
-			const Vertex * operator()(int i) const {return TriaVertices[i];};
-			Vertex * & operator()(int i)  {return TriaVertices[i];};
+			const MeshVertex & operator[](int i) const {return *TriaVertices[i];};
+			MeshVertex & operator[](int i)  {return *TriaVertices[i];};
+			const MeshVertex * operator()(int i) const {return TriaVertices[i];};
+			MeshVertex * & operator()(int i)  {return TriaVertices[i];};
 
 			//Methods
@@ -57,5 +57,5 @@
 			TriangleAdjacent Adj(int i)  const {return TriangleAdjacent(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
 			Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];}
-			Triangle* Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const ;
+			Triangle* Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const ;
 			void  ReNumbering(Triangle *tb,Triangle *te, long *renu){
 				if (link  >=tb && link  <te) link  = tb + renu[link -tb];
@@ -64,5 +64,5 @@
 				if (TriaAdjTriangles[2] >=tb && TriaAdjTriangles[2] <te) TriaAdjTriangles[2] = tb + renu[TriaAdjTriangles[2]-tb];    
 			}
-			void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
+			void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){
 				if (TriaVertices[0] >=vb && TriaVertices[0] <ve) TriaVertices[0] = vb + renu[TriaVertices[0]-vb];
 				if (TriaVertices[1] >=vb && TriaVertices[1] <ve) TriaVertices[1] = vb + renu[TriaVertices[1]-vb];
@@ -123,5 +123,5 @@
 			double qualite() ;
 			void  Set(const Triangle &,const Triangles &,Triangles &);
-			int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
+			int   In(MeshVertex *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 3406)
+++ /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp	(revision 3407)
@@ -41,10 +41,10 @@
 	/*}}}*/
 	/*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/
-	Vertex* TriangleAdjacent::EdgeVertex(const int & i) const {
+	MeshVertex* TriangleAdjacent::EdgeVertex(const int & i) const {
 		return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
 	}
 	/*}}}*/
 	/*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/
-	Vertex* TriangleAdjacent::OppositeVertex() const {
+	MeshVertex* TriangleAdjacent::OppositeVertex() const {
 		return t->TriaVertices[bamg::OppositeVertex[a]]; 
 	}
Index: /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 
 namespace bamg {
@@ -43,6 +43,6 @@
 			int  swap();
 			TriangleAdjacent Adj() const;
-			Vertex* EdgeVertex(const int & i) const;
-			Vertex* OppositeVertex() const;
+			MeshVertex* EdgeVertex(const int & i) const;
+			MeshVertex* OppositeVertex() const;
 			Icoor2& det() const;
 	};
Index: /issm/trunk/src/c/Bamgx/objects/Triangles.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 3407)
@@ -267,6 +267,6 @@
 		//Vertices
 		if (verbose) printf("Reading vertices (%i)\n",nbv);
-		vertices=(Vertex*)xmalloc(nbv*sizeof(Vertex));
-		ordre=(Vertex**)xmalloc(nbv*sizeof(Vertex*));
+		vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex));
+		ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*));
 		for (i=0;i<nbv;i++){
 			vertices[i].r.x=x[i];
@@ -319,6 +319,6 @@
 			if(verbose>5) printf("      processing Vertices\n");
 
-			vertices=(Vertex*)xmalloc(nbv*sizeof(Vertex));
-			ordre=(Vertex**)xmalloc(nbv*sizeof(Vertex*));
+			vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex));
+			ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*));
 
 			for (i=0;i<nbv;i++){
@@ -450,5 +450,5 @@
 			for (i=0;i<nbe;i++){
 				for (j=0;j<2;j++) { 
-					Vertex *v=edges[i].v[j];
+					MeshVertex *v=edges[i].v[j];
 					long i0=v->color,j0;
 					if(i0==-1){
@@ -726,5 +726,5 @@
 				Triangle &t =triangles[i];
 				Triangle* ta;
-				Vertex *v0,*v1,*v2,*v3;
+				MeshVertex *v0,*v1,*v2,*v3;
 				if (reft[i]<0) continue;
 				if ((ta=t.Quadrangle(v0,v1,v2,v3)) !=0 && &t<ta) { 
@@ -775,5 +775,5 @@
 				VertexOnGeom &v=VerticesOnGeomVertex[i];
 				ISSMASSERT(v.OnGeomVertex());
-				bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((Vertex*)v)+1; //back to Matlab indexing
+				bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing
 				bamgmesh->VerticesOnGeometricVertex[i*2+1]=Gh.Number((GeometricalVertex*)v)+1; //back to Matlab indexing
 			}
@@ -791,5 +791,5 @@
 					ISSMERROR(exprintf("A vertices supposed to be OnGeometricEdge is actually not"));
 				}
-				bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number((Vertex*)v)+1; //back to Matlab indexing
+				bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing
 				bamgmesh->VerticesOnGeometricEdge[i*3+1]=Gh.Number((const GeometricalEdge*)v)+1; //back to Matlab indexing
 				bamgmesh->VerticesOnGeometricEdge[i*3+2]=(double)v; //absisce
@@ -1020,5 +1020,5 @@
 			for (int j=0;j<2;j++){
 
-				Vertex V;
+				MeshVertex V;
 				VertexOnGeom GV;
 				Gh.ProjectOnCurve(edges[i],ss[j],V,GV);
@@ -1066,5 +1066,5 @@
 	/*}}}1*/
 	/*FUNCTION Triangles::AddVertex{{{1*/
-	void Triangles::AddVertex( Vertex &s,Triangle* t, Icoor2* det3) {
+	void Triangles::AddVertex( MeshVertex &s,Triangle* t, Icoor2* det3) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Add)*/
 		// -------------------------------------------
@@ -1086,5 +1086,5 @@
 		Triangle* tt[3];
 		//three vertices of t
-		Vertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2];
+		MeshVertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2];
 		//three determinants
 		Icoor2 det3local[3];
@@ -1435,5 +1435,5 @@
 			for (j=0;j<2;j++){ 
 				//get current vertex
-				Vertex* v=edges[i].v[j];
+				MeshVertex* v=edges[i].v[j];
 				//get vertex color (i0)
 				long i0=v->color;
@@ -1575,5 +1575,5 @@
 		for (i=0;i<nbv;i++){
 			if((j=colorV[i])>=0){
-				Vertex & v = Gh.vertices[j];
+				MeshVertex & v = Gh.vertices[j];
 				v = vertices[i];
 				v.color =0;
@@ -2326,5 +2326,5 @@
 		delete [] Edgeflags;
 
-		//Reset Vertex to On
+		//Reset MeshVertex to On
 		SetVertexFieldOn();
 
@@ -2560,5 +2560,5 @@
 						ISSMERROR(exprintf("&e==NULL"));
 					}
-					Vertex * v0 =  e(0),*v1 = e(1);
+					MeshVertex * v0 =  e(0),*v1 = e(1);
 					Triangle *t  = v0->t;
 					int sens = Gh.subdomains[i].sens;
@@ -2640,5 +2640,5 @@
 				ISSMERROR(exprintf("no starting triangle provided and no quadtree available"));
 			}
-			Vertex *a = quadtree->NearestVertex(B.x,B.y) ;
+			MeshVertex *a = quadtree->NearestVertex(B.x,B.y) ;
 
 			if (!a || !a->t ) {
@@ -2739,5 +2739,5 @@
 		R2 AB;
 		GeometricalVertex *a,*b;
-		Vertex *va,*vb;
+		MeshVertex *va,*vb;
 		GeometricalEdge * e;
 
@@ -3118,5 +3118,5 @@
 			if (vog.IsRequiredVertex()){
 				GeometricalVertex* gv=vog;
-				Vertex *bv = vog;
+				MeshVertex *bv = vog;
 				ISSMASSERT(gv->to); // use of Geom -> Th
 				VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->to,bv);
@@ -3205,7 +3205,7 @@
 						long i=0;// index of new points on the curve
 						register GeometricalVertex * GA0 = *(*peequi)[k0equi].onGeometry;
-						Vertex *A0;
+						MeshVertex *A0;
 						A0 = GA0->to;  // the vertex in new mesh
-						Vertex *A1;
+						MeshVertex *A1;
 						VertexOnGeom *GA1;
 						Edge* PreviousNewEdge = 0;
@@ -3225,5 +3225,5 @@
 								ISSMASSERT(pe && ee.onGeometry);
 								ee.onGeometry->SetMark();
-								Vertex & v0=ee[0], & v1=ee[1];
+								MeshVertex & v0=ee[0], & v1=ee[1];
 								R2 AB=(R2)v1-(R2)v0;
 								double L0=L,LAB;
@@ -3431,5 +3431,5 @@
 		 * the initial simple mesh from this edge and 2 boundary triangles*/
 
-		Vertex *  v0=ordre[0], *v1=ordre[1];
+		MeshVertex *  v0=ordre[0], *v1=ordre[1];
 
 		nbt = 2;
@@ -3471,5 +3471,5 @@
 
 			//Get new vertex
-			Vertex *newvertex=ordre[icount];
+			MeshVertex *newvertex=ordre[icount];
 
 			//Find the triangle in which newvertex is located
@@ -3548,5 +3548,5 @@
 		long iv=nbvold;
 		for (i=nbvold;i<nbv;i++){
-			Vertex &vi=*ordre[i];
+			MeshVertex &vi=*ordre[i];
 			vi.i=toI2(vi.r);
 			vi.r=toR2(vi.i);
@@ -3556,5 +3556,5 @@
 			if (!quadtree->ToClose(vi,seuil,hi,hj)){
 				// a good new point 
-				Vertex &vj = vertices[iv];
+				MeshVertex &vj = vertices[iv];
 				long  j=vj.ReferenceNumber; 
 				if (&vj!=ordre[j]){
@@ -3703,6 +3703,6 @@
 				Triangle &tt = *t.TriangleAdj(j);
 				if ( ! &tt ||  it < Number(tt) && ( tt.link || t.link)){
-					Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
-					Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
+					MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
+					MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
 					R2 AB= (R2) v1-(R2) v0;
 					Metric M = v0;
@@ -3762,5 +3762,5 @@
 	/*}}}1*/
 /*FUNCTION Triangles::NearestVertex{{{1*/
-Vertex * Triangles::NearestVertex(Icoor1 i,Icoor1 j) {
+MeshVertex* Triangles::NearestVertex(Icoor1 i,Icoor1 j) {
 	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/
 	return  quadtree->NearestVertex(i,j); 
@@ -3787,5 +3787,5 @@
 			if (verbosity>5) printf("         Inserting initial mesh points\n");
 			for (i=0;i<Bh.nbv;i++){ 
-				Vertex &bv=Bh[i];
+				MeshVertex &bv=Bh[i];
 				if (!bv.onGeometry){
 					vertices[nbv].r   = bv.r;
@@ -3826,6 +3826,6 @@
 				for(j=0;j<3;j++){
 					TriangleAdjacent tj(t,j);
-					Vertex &vA = *tj.EdgeVertex(0);
-					Vertex &vB = *tj.EdgeVertex(1);
+					MeshVertex &vA = *tj.EdgeVertex(0);
+					MeshVertex &vB = *tj.EdgeVertex(1);
 
 					//if t is a boundary triangle, or tj locked, continue
@@ -3858,5 +3858,5 @@
 			// for all the triangle containing the vertex i
 			for (i=nbvold;i<nbv;i++){ 
-				Vertex*          s  = vertices + i;
+				MeshVertex*          s  = vertices + i;
 				TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]);
 				Triangle*        tbegin= (Triangle*) ta;
@@ -3917,9 +3917,9 @@
 
 	if (inbvx) {
-		vertices=new Vertex[nbvx];
+		vertices=new MeshVertex[nbvx];
 		if (!vertices){
 			ISSMERROR(exprintf("!vertices"));
 		}
-		ordre=new (Vertex* [nbvx]);
+		ordre=new (MeshVertex* [nbvx]);
 		if (!ordre){
 			ISSMERROR(exprintf("!ordre"));
@@ -3948,6 +3948,6 @@
 /*}}}1*/
 	/*FUNCTION Triangles::ProjectOnCurve{{{1*/
-	GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, Vertex &  vA, Vertex & vB,
-				double theta,Vertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
+	GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, MeshVertex &  vA, MeshVertex & vB,
+				double theta,MeshVertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
 		/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/
 
@@ -3955,5 +3955,5 @@
 		double tA=0,tB=0;
 		R2 A=vA,B=vB;
-		Vertex * pvA=&vA, * pvB=&vB;
+		MeshVertex * pvA=&vA, * pvB=&vB;
 		if (vA.vint == IsVertexOnVertex){
 			pA=vA.onBackgroundVertex;
@@ -3964,5 +3964,5 @@
 		}
 		else {
-			ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA)));
+			ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA)));
 		} 
 
@@ -3975,5 +3975,5 @@
 		}
 		else {
-			ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB)));
+			ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB)));
 		} 
 		Edge * e = &BhAB;
@@ -4026,5 +4026,5 @@
 			//    2 for find the vertex 
 			int  iii;
-			Vertex  *v0=pvA,*v1; 
+			MeshVertex  *v0=pvA,*v1; 
 			Edge *neee,*eee;
 			double lg =0; // length of the curve 
@@ -4227,5 +4227,5 @@
 
 	/*Reconstruct mesh beginning with 2 triangles*/
-	Vertex *  v0=ordre[0], *v1=ordre[1];
+	MeshVertex *  v0=ordre[0], *v1=ordre[1];
 
 	triangles[0](0) = NULL; // Infinite vertex
@@ -4260,5 +4260,5 @@
 	long NbSwap=0;
 	for (int icount=2; icount<nbvb; icount++) {
-		Vertex *vi  = ordre[icount];
+		MeshVertex *vi  = ordre[icount];
 		Icoor2 dete[3];
 		Triangle *tcvi = FindTriangleContaining(vi->i,dete);
@@ -4273,5 +4273,5 @@
 	for ( i = 0; i < nbe; i++){
 		if (st[i] >=0){ //edge alone => on border
-			Vertex &a=edges[i][0], &b=edges[i][1];
+			MeshVertex &a=edges[i][0], &b=edges[i][1];
 			if (a.t && b.t){
 				knbe++;
@@ -4298,6 +4298,6 @@
 					// change the link of ta;
 					int ja = ta;
-					Vertex *v0= ta.EdgeVertex(0);
-					Vertex *v1= ta.EdgeVertex(1);
+					MeshVertex *v0= ta.EdgeVertex(0);
+					MeshVertex *v1= ta.EdgeVertex(1);
 					long k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv);
 
@@ -4313,5 +4313,5 @@
 	for (i=0;i<nbt;i++){
 		if (triangles[i].link) {
-			triangles[i]=Triangle((Vertex *) NULL,(Vertex *) NULL,(Vertex *) NULL);
+			triangles[i]=Triangle((MeshVertex *) NULL,(MeshVertex *) NULL,(MeshVertex *) NULL);
 			triangles[i].color=-1;
 		}
@@ -4379,5 +4379,5 @@
 						printf("This edge is on geometrical edge number %i\n",Gh.Number(edges[i].onGeometry)+1);
 						if (edges[i][j].onGeometry->OnGeomVertex())
-						 printf("the vertex number %i of this edge is a geometric Vertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1);
+						 printf("the vertex number %i of this edge is a geometric MeshVertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1);
 						else if (edges[i][j].onGeometry->OnGeomEdge())
 						 printf("the vertex number %i of this edge is a geometric Edge number %i\n",Gh.Number(edges[i][j].onGeometry->ge)+1);
@@ -4471,5 +4471,5 @@
 		// from on mesh to over mesh 
 		//  --  so do ReNumbering at the beginning
-		Vertex * ve = vertices+nbv;
+		MeshVertex * ve = vertices+nbv;
 		long it,ie,i;
 
@@ -4485,5 +4485,5 @@
 		for (i=0;i< NbVerticesOnGeomVertex;i++)
 		  {
-			Vertex *v = VerticesOnGeomVertex[i].mv;
+			MeshVertex *v = VerticesOnGeomVertex[i].mv;
 			if (v>=vertices && v < ve)
 			 VerticesOnGeomVertex[i].mv=vertices+renu[Number(v)];
@@ -4493,5 +4493,5 @@
 		for (i=0;i< NbVerticesOnGeomEdge;i++)
 		  {
-			Vertex *v =VerticesOnGeomEdge[i].mv;
+			MeshVertex *v =VerticesOnGeomEdge[i].mv;
 			if (v>=vertices && v < ve)
 			 VerticesOnGeomEdge[i].mv=vertices+renu[Number(v)];
@@ -4501,5 +4501,5 @@
 		for (i=0;i< NbVertexOnBThVertex;i++)
 		  {
-			Vertex *v=VertexOnBThVertex[i].v;
+			MeshVertex *v=VertexOnBThVertex[i].v;
 			if (v>=vertices && v < ve)
 			 VertexOnBThVertex[i].v=vertices+renu[Number(v)];
@@ -4508,5 +4508,5 @@
 		for (i=0;i< NbVertexOnBThEdge;i++)
 		  {
-			Vertex *v=VertexOnBThEdge[i].v;
+			MeshVertex *v=VertexOnBThEdge[i].v;
 			if (v>=vertices && v < ve)
 			 VertexOnBThEdge[i].v=vertices+renu[Number(v)];
@@ -4520,5 +4520,5 @@
 			{ 
 			 i=it;
-			 Vertex ti=vertices[i],tj;
+			 MeshVertex ti=vertices[i],tj;
 			 while ( (j=renu[i]) >= 0){
 				 // i is old, and j is new 
@@ -4572,7 +4572,7 @@
 	int Nberr=0;
 	for (i=0;i<nbt;i++) {
-		Vertex & v0 = triangles[i][0];
-		Vertex & v1 = triangles[i][1];
-		Vertex & v2 = triangles[i][2];
+		MeshVertex & v0 = triangles[i][0];
+		MeshVertex & v1 = triangles[i][1];
+		MeshVertex & v2 = triangles[i][2];
 
 		//If this is not a boundary triangle
@@ -4635,5 +4635,5 @@
 			 hmin=Min(hmin,he);
 			 hmax=Max(hmax,he);
-			 Vertex & v=K[j];
+			 MeshVertex & v=K[j];
 			 D2xD2 M((Metric)v);
 			 betaK += sqrt(M.det());
@@ -4680,6 +4680,6 @@
 			 if ( !ta || !ta->link || Number(ta) >= it) 
 				{ 
-				 Vertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]];
-				 Vertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]];
+				 MeshVertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]];
+				 MeshVertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]];
 				 if ( !& vP || !&vQ) continue;
 				 R2 PQ = vQ.r - vP.r;
@@ -4777,7 +4777,7 @@
 				ISSMERROR(exprintf("!t"));
 			}
-			Vertex & vi = vertices[i];
+			MeshVertex & vi = vertices[i];
 			TriangleAdjacent ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
-			Vertex *pvj0 = ta.EdgeVertex(0);
+			MeshVertex *pvj0 = ta.EdgeVertex(0);
 			while (1) {
 				ta=Previous(Adj(ta));
@@ -4785,5 +4785,5 @@
 					ISSMERROR(exprintf("vertices+i != ta.EdgeVertex(1)"));
 				}
-				Vertex & vj = *(ta.EdgeVertex(0));
+				MeshVertex & vj = *(ta.EdgeVertex(0));
 				if ( &vj ) {
 					j= &vj-vertices;
@@ -4924,6 +4924,6 @@
 					// get the Info on background mesh 
 					double s =        newVertexOnBThEdge[kvb];
-					Vertex &  bv0  = newVertexOnBThEdge[kvb][0];
-					Vertex &  bv1  = newVertexOnBThEdge[kvb][1];
+					MeshVertex &  bv0  = newVertexOnBThEdge[kvb][0];
+					MeshVertex &  bv1  = newVertexOnBThEdge[kvb][1];
 					// compute the metrix of the new points 
 					vertices[k].m =  Metric(1-s,bv0,s,bv1); 
@@ -4993,6 +4993,6 @@
 				if (&tt >= lastT)
 				 t.SetAdj2(j,0,0);// unset adj
-				const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];
-				const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];
+				const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
+				const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
 				long  ke =edge4->SortAndFind(Number(v0),Number(v1));
 				if (ke>0) 
@@ -5004,5 +5004,5 @@
 					if (ii<nbt) // good triangle
 					 kedge[3*ii+jj] = ks;
-					Vertex &A=vertices[ks];
+					MeshVertex &A=vertices[ks];
 					double aa,bb,cc,dd;
 					if ((dd=Area2(v0.r,v1.r,A.r)) >=0){
@@ -5042,6 +5042,6 @@
 
 
-				const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];
-				const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];
+				const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
+				const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
 				if ( kedge[3*i+j] < 0) 
 				  {
@@ -5122,7 +5122,7 @@
 
 			Triangle &t0=triangles[i];
-			Vertex * v0=t0(i0);           
-			Vertex * v1=t0(i1);           
-			Vertex * v2=t0(i2);
+			MeshVertex * v0=t0(i0);           
+			MeshVertex * v1=t0(i1);           
+			MeshVertex * v2=t0(i2);
 
 			if (nbmkadj>=10){
@@ -5147,5 +5147,5 @@
 								ISSMERROR(exprintf("kedge[3*i+i0]<0"));
 							}
-							Vertex * v3 = vertices + kedge[3*i+k0];
+							MeshVertex * v3 = vertices + kedge[3*i+k0];
 
 							t0(i2) = v3;
@@ -5167,6 +5167,6 @@
 							}
 
-							Vertex * v01 = vertices + kedge[3*i+k2];
-							Vertex * v02 = vertices + kedge[3*i+k1]; 
+							MeshVertex * v01 = vertices + kedge[3*i+k2];
+							MeshVertex * v02 = vertices + kedge[3*i+k1]; 
 							t0(i1) = v01; 
 							t0(i2) = v02; 
@@ -5190,7 +5190,7 @@
 								ISSMERROR(exprintf("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0"));
 							}
-							Vertex * v12 = vertices + kedge[3*i+k0];
-							Vertex * v02 = vertices + kedge[3*i+k1]; 
-							Vertex * v01 = vertices + kedge[3*i+k2];
+							MeshVertex * v12 = vertices + kedge[3*i+k0];
+							MeshVertex * v02 = vertices + kedge[3*i+k1]; 
+							MeshVertex * v01 = vertices + kedge[3*i+k2];
 							t0(i1) = v01;
 							t0(i2) = v02;
@@ -5237,5 +5237,5 @@
 									double a3[]={1./3.,1./3.,1./3.};
 									vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
-									Vertex * vc =  vertices +nbv++;
+									MeshVertex * vc =  vertices +nbv++;
 									t3(i0) = vc;
 									t4(i1) = vc;
@@ -5353,6 +5353,6 @@
 			  if ( &tt && tt.link && it < Number(tt)) 
 				 { // an internal edge 
-				  Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
-				  Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
+				  MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
+				  MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
 				  if (v0.onGeometry && v1.onGeometry){
 					  R2 P= ((R2) v0 + (R2) v1)*0.5;
@@ -5374,5 +5374,5 @@
 		Icoor2 dete[3];  
 		for (int i=nbvold;i<nbv;i++) {// for all the new point
-			Vertex & vi = vertices[i];
+			MeshVertex & vi = vertices[i];
 			vi.i = toI2(vi.r);
 			vi.r = toR2(vi.i);
@@ -5477,6 +5477,6 @@
 				ISSMERROR(exprintf("kkk>=1000"));
 			}
-			Vertex  &vI =  *edge.EdgeVertex(0);
-			Vertex  &vJ =  *edge.EdgeVertex(1);
+			MeshVertex  &vI =  *edge.EdgeVertex(0);
+			MeshVertex  &vJ =  *edge.EdgeVertex(1);
 			I2 I=vI, J=vJ, IJ= J-I;
 			IJ_IA = (IJ ,(A-I));
@@ -5518,5 +5518,5 @@
 		// the probleme is in case of  the fine and long internal hole
 		// for exemple neart the training edge of a wing
-		Vertex * s=0,*s1=0, *s0=0;
+		MeshVertex * s=0,*s1=0, *s0=0;
 		Icoor2 imax = MaxICoor22;
 		Icoor2 l0 = imax,l1 = imax;
@@ -5605,5 +5605,5 @@
 				if ((link + linkp) == 1) 
 				  { // a boundary edge 
-					Vertex * st = edge.EdgeVertex(1);
+					MeshVertex * st = edge.EdgeVertex(1);
 					I2 I=*st;
 					Icoor2  ll = Norme2_2 (C-I);
@@ -5650,5 +5650,5 @@
 	/*}}}1*/
 /*FUNCTION ForceEdge{{{1*/
-int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  { 
+int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret)  { 
 	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
 
@@ -5661,5 +5661,5 @@
 
 	TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
-	Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
+	MeshVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
 	// we turn around a in the  direct sens  
 
@@ -5686,5 +5686,5 @@
 		if((det1 < 0) && (det2 >0)) { 
 			// try to force the edge 
-			Vertex * va = &a, *vb = &b;
+			MeshVertex * va = &a, *vb = &b;
 			tc = Previous(tc);
 			if (!v1 || !v2){
@@ -5696,5 +5696,5 @@
 				 ISSMERROR(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);
+			MeshVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
 			if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
 				tc.SetLock();
@@ -5726,5 +5726,5 @@
 /*}}}1*/
 /*FUNCTION swap{{{1*/
-void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){ 
+void  swap(Triangle *t1,short a1, Triangle *t2,short a2, MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2){ 
 	/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
 	// --------------------------------------------------------------
@@ -5771,5 +5771,5 @@
 /*}}}1*/
 	/*FUNCTION SwapForForcingEdge{{{1*/
-	int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
+	int SwapForForcingEdge(MeshVertex   *  & pva ,MeshVertex  * &   pvb ,TriangleAdjacent & 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
@@ -5788,7 +5788,7 @@
 		}
 
-		Vertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]];
-		Vertex & s1= (*t1)[OppositeVertex[a1]];
-		Vertex & s2= (*t2)[OppositeVertex[a2]];
+		MeshVertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]];
+		MeshVertex & s1= (*t1)[OppositeVertex[a1]];
+		MeshVertex & s2= (*t2)[OppositeVertex[a2]];
 
 
Index: /issm/trunk/src/c/Bamgx/objects/Triangles.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangles.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/Triangles.h	(revision 3407)
@@ -14,5 +14,5 @@
 #include "DoubleAndInt.h"
 #include "Direction.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "TriangleAdjacent.h"
 #include "Edge.h"
@@ -48,5 +48,5 @@
 			long NbOfTriangleSearchFind;
 			long NbOfSwapTriangle;
-			Vertex* vertices;
+			MeshVertex* vertices;
 			long NbVerticesOnGeomVertex;
 			VertexOnGeom * VerticesOnGeomVertex;
@@ -66,5 +66,5 @@
 			Edge* edges; 
 			QuadTree* quadtree;
-			Vertex** ordre;
+			MeshVertex** ordre;
 			SubDomain* subdomains;
 			ListofIntersectionTriangles lIntTria;
@@ -86,6 +86,6 @@
 
 			//Operators
-			const Vertex & operator[]  (long i) const { return vertices[i];};
-			Vertex & operator[](long i) { return vertices[i];};
+			const MeshVertex & operator[]  (long i) const { return vertices[i];};
+			MeshVertex & operator[](long i) { return vertices[i];};
 			const Triangle & operator()  (long i) const { return triangles[i];};
 			Triangle & operator()(long i) { return triangles[i];};
@@ -101,5 +101,5 @@
 				return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
 			}
-			void AddVertex(Vertex & s,Triangle * t,Icoor2 *  =0) ;
+			void AddVertex(MeshVertex & s,Triangle * t,Icoor2 *  =0) ;
 			void Insert();
 			void ForceBoundary();
@@ -124,13 +124,13 @@
 			void SmoothingVertex(int =3,double=0.3);
 			Metric MetricAt (const R2 &) const;
-			GeometricalEdge* ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,double theta, Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
+			GeometricalEdge* ProjectOnCurve( Edge & AB, MeshVertex &  A, MeshVertex & B,double theta, MeshVertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
 			long Number(const Triangle & t) const  { return &t - triangles;}
 			long Number(const Triangle * t) const  { return t - triangles;}
-			long Number(const Vertex & t) const  { return &t - vertices;}
-			long Number(const Vertex * t) const  { return t - vertices;}
+			long Number(const MeshVertex & t) const  { return &t - vertices;}
+			long Number(const MeshVertex * t) const  { return t - vertices;}
 			long Number(const Edge & t) const  { return &t - edges;}
 			long Number(const Edge * t) const  { return t - edges;}
 			long Number2(const Triangle * t) const  { return t - triangles; }
-			Vertex* NearestVertex(Icoor1 i,Icoor1 j) ;
+			MeshVertex* NearestVertex(Icoor1 i,Icoor1 j) ;
 			Triangle* FindTriangleContaining(const I2 & ,Icoor2 [3],Triangle *tstart=0) const;
 			void ReadMesh(double* index,double* x,double* y,int nods,int nels);
@@ -180,9 +180,9 @@
 	void  swap(Triangle *t1,short a1,
 				Triangle *t2,short a2,
-				Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);
-	int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,
+				MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2);
+	int SwapForForcingEdge(MeshVertex   *  & pva ,MeshVertex  * &   pvb ,
 				TriangleAdjacent & tt1,Icoor2 & dets1,
 				Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
-	int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret) ;
+	int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret) ;
 	inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
 		return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
@@ -197,5 +197,5 @@
 		int j=i;i=on->DirAdj[i];on=on->Adj[j];
 	}
-	inline double qualite(const Vertex &va,const Vertex &vb,const Vertex &vc){
+	inline double qualite(const MeshVertex &va,const MeshVertex &vb,const MeshVertex &vc){
 		double ret; 
 		I2 ia=va,ib=vb,ic=vc;
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "Edge.h"
 
@@ -20,17 +20,17 @@
 
 		public:
-			Vertex* v;
+			MeshVertex* v;
 			Edge*   be;
 			double abcisse;
 
 			//Constructors
-			VertexOnEdge( Vertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}
+			VertexOnEdge( MeshVertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}
 			VertexOnEdge(){}
 
 			//Operators
 			operator double () const { return abcisse;}
-			operator Vertex* () const { return v;}  
+			operator MeshVertex* () const { return v;}  
 			operator Edge* () const { return be;}  
-			Vertex & operator[](int i) const { return (*be)[i];}
+			MeshVertex & operator[](int i) const { return (*be)[i];}
 
 			//Methods
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 #include "GeometricalVertex.h"
 #include "GeometricalEdge.h"
@@ -22,5 +22,5 @@
 		public:
 
-			Vertex* mv;
+			MeshVertex* mv;
 			double abscisse;  
 			union{ 
@@ -31,9 +31,9 @@
 			//Constructors/Destructors
 			VertexOnGeom(): mv(0),abscisse(0){gv=0;} 
-			VertexOnGeom(Vertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}
-			VertexOnGeom(Vertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}
+			VertexOnGeom(MeshVertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}
+			VertexOnGeom(MeshVertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}
 
 			//Operators
-			operator Vertex*() const  {return mv;}
+			operator MeshVertex*() const  {return mv;}
 			operator GeometricalVertex * () const  {return gv;}
 			operator GeometricalEdge * () const  {return ge;}
Index: /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h	(revision 3406)
+++ /issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h	(revision 3407)
@@ -9,5 +9,5 @@
 #include "../include/typedefs.h"
 #include "../include/macros.h"
-#include "BamgVertex.h"
+#include "MeshVertex.h"
 
 namespace bamg {
@@ -19,9 +19,9 @@
 
 		public:
-			Vertex* v;
-			Vertex* bv;
+			MeshVertex* v;
+			MeshVertex* bv;
 
 			//Constructors
-			VertexOnVertex(Vertex * w,Vertex *bw) :v(w),bv(bw){}
+			VertexOnVertex(MeshVertex * w,MeshVertex *bw) :v(w),bv(bw){}
 			VertexOnVertex() {};