Index: /issm/trunk/src/c/Bamgx/Bamgx.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/Bamgx.cpp	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/Bamgx.cpp	(revision 2981)
@@ -83,5 +83,5 @@
 		if (verbosity>1) printf("   Generating Metric...\n");
 		for(i=0;i<Gh.nbv;i++){
-			MetricAnIso M=Gh[i];
+			Metric M=Gh[i];
 			MatVVP2x2 Vp(M/coef);
 			Vp.Maxh(hmax);
Index: /issm/trunk/src/c/Bamgx/Mesh2.h
===================================================================
--- /issm/trunk/src/c/Bamgx/Mesh2.h	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/Mesh2.h	(revision 2981)
@@ -23,8 +23,7 @@
 namespace bamg {
 
-	const  double Pi =  3.14159265358979323846264338328;
-	const  float fPi =  3.14159265358979323846264338328;
-
-	extern int hinterpole;
+	//Some parameters
+	const double Pi =3.141592653589793238462643383279502884197169399375105820974944592308;
+	const float  fPi=3.141592653589793238462643383279502884197169399375105820974944592308;
 
 	inline int BinaryRand(){
@@ -37,8 +36,9 @@
 	} 
 
+	//typedef
 	typedef P2<Icoor1,Icoor2> I2;
-	typedef P2xP2<Int2,Int4> I2xI2;
-	typedef P2<Real8,Real8> R2;
-	typedef P2<Real4,Real8> R2xR2;
+	typedef P2xP2<Int2,Int4>  I2xI2;
+	typedef P2<Real8,Real8>   R2;
+	typedef P2<Real4,Real8>   R2xR2;
 }
 
Index: /issm/trunk/src/c/Bamgx/Metric.h
===================================================================
--- /issm/trunk/src/c/Bamgx/Metric.h	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/Metric.h	(revision 2981)
@@ -1,4 +1,4 @@
 #ifndef TYPEMETRIX
-#define TYPEMETRIX MetricAnIso
+#define TYPEMETRIX Metric
 #endif
 
@@ -9,51 +9,16 @@
 	typedef P2xP2<double,double> D2xD2;
 
-	class  MetricAnIso;
+	class Metric;
 	class MatVVP2x2;
-	class MetricIso;
-
-	typedef TYPEMETRIX Metric;
 
 
-	class MetricIso{
-		friend class MatVVP2x2;
-		Real4 h;
-		public:
-		MetricIso(Real4 a): h(a){}
-		MetricIso(const MetricAnIso M);// {MatVVP2x2 vp(M);h=1/sqrt(Max(vp.lambda1,vp.lambda2));}
-		MetricIso(Real8 a11,Real8 a21,Real8 a22);// {*this=MetricAnIso(a11,a21,a22));}
-		MetricIso(): h(1) {}; // 
-		MetricIso(const Real8  a[3],const  MetricIso m0,
-					const  MetricIso m1,const  MetricIso m2 )
-		  : h(hinterpole 
-					  ? (a[0]*m0.h+a[1]*m1.h+a[2]*m2.h)
-					  : 1/sqrt(a[0]/(m0.h*m0.h)+a[1]/(m1.h*m1.h)+a[2]/(m2.h*m2.h))) {}
-		MetricIso(const Real8  a,const  MetricIso ma,
-					const Real8  b,const  MetricIso mb)
-		  : h(hinterpole
-					  ? a*ma.h+b*mb.h
-					  :1/sqrt(a/(ma.h*ma.h)+b/(mb.h*mb.h))) {}
-		R2 Orthogonal(const R2 A)const {return R2(-h*A.y,h*A.x);}
-		R2 Orthogonal(const I2 A)const {return R2(-h*A.y,h*A.x);}
-		//  D2 Orthogonal(const D2 A)const {return D2(-h*A.y,h*A.x);}
-		Real8 operator()(R2 x) const { return sqrt((x,x))/h;};
-		Real8 operator()(R2 x,R2 y) const { return ((x,y))/(h*h);};
-		int  IntersectWith(MetricIso M) {int change=0;if (M.h<h) change=1,h=M.h;return change;}
-		MetricIso operator*(Real8 c) const {return  MetricIso(h/c);} 
-		MetricIso operator/(Real8 c) const {return  MetricIso(h*c);}
-		Real8 det() const {return 1./(h*h*h*h);}    
-		operator D2xD2(){ return D2xD2(1/(h*h),0.,0.,1/(h*h));}
-		void     Box(Real4 & hx,Real4 & hy) { hx=h,hy=h;}
-	};
-
-
-	class MetricAnIso{ public:
+	class Metric{ public:
 		friend class MatVVP2x2;
 		Real8 a11,a21,a22;
-		MetricAnIso(Real8 a): a11(1/(a*a)),a21(0),a22(1/(a*a)){}
-		MetricAnIso(Real8 a,Real8 b,Real8 c) :a11(a),a21(b),a22(c){}
-		MetricAnIso()  {}; // 
-		MetricAnIso(const Real8  a[3],const  MetricAnIso m0,
-					const  MetricAnIso m1,const  MetricAnIso m2 );
+		Metric(Real8 a): a11(1/(a*a)),a21(0),a22(1/(a*a)){}
+		Metric(Real8 a,Real8 b,Real8 c) :a11(a),a21(b),a22(c){}
+		Metric()  {}; // 
+		Metric(const Real8  a[3],const  Metric m0,
+					const  Metric m1,const  Metric m2 );
 		R2 mul(const R2 x)const {return R2(a11*x.x+a21*x.y,a21*x.x+a22*x.y);}
 		Real8 det() const {return a11*a22-a21*a21;}  
@@ -61,9 +26,9 @@
 		R2 Orthogonal(const I2 x){return R2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y);}
 		//  D2 Orthogonal(const D2 x){return D2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y);}
-		MetricAnIso( Real8  a,const  MetricAnIso ma,
-					Real8  b,const  MetricAnIso mb);
-		int  IntersectWith(const MetricAnIso M2);
-		MetricAnIso operator*(Real8 c) const {Real8 c2=c*c;return  MetricAnIso(a11*c2,a21*c2,a22*c2);} 
-		MetricAnIso operator/(Real8 c) const {Real8 c2=1/(c*c);return  MetricAnIso(a11*c2,a21*c2,a22*c2);} 
+		Metric( Real8  a,const  Metric ma,
+					Real8  b,const  Metric mb);
+		int  IntersectWith(const Metric M2);
+		Metric operator*(Real8 c) const {Real8 c2=c*c;return  Metric(a11*c2,a21*c2,a22*c2);} 
+		Metric operator/(Real8 c) const {Real8 c2=1/(c*c);return  Metric(a11*c2,a21*c2,a22*c2);} 
 		operator D2xD2(){ return D2xD2(a11,a21,a21,a22);}
 
@@ -72,11 +37,10 @@
 		Real8 operator()(R2 x,R2 y) const { return x.x*y.x*a11+(x.x*x.y+x.y*y.x)*a21+x.y*y.y*a22;};
 		inline void  Box(Real4 &hx,Real4 &hy) const ;  
-		MetricAnIso(const MatVVP2x2);
+		Metric(const MatVVP2x2);
 		void  Echo();
 	};
 
 	class MatVVP2x2{
-		friend  class MetricAnIso;
-		friend  class MetricIso;
+		friend  class Metric;
 		public:
 		double lambda1,lambda2;
@@ -94,6 +58,5 @@
 		void Maxh(double h) {Max(1.0/(h*h));}
 		void Isotrope() {lambda1=lambda2=bamg::Max(lambda1,lambda2);}
-		MatVVP2x2(const MetricAnIso );
-		MatVVP2x2(const MetricIso M) :  lambda1(1/(M.h*M.h)),lambda2(1/(M.h*M.h)),v(1,0) {}
+		MatVVP2x2(const Metric );
 		Real8 hmin() const {return sqrt(1/bamg::Max3(lambda1,lambda2,1e-30));}
 		Real8 hmax() const {return sqrt(1/bamg::Max(bamg::Min(lambda1,lambda2),1e-30));}
@@ -122,7 +85,7 @@
 	}
 
-	void  SimultaneousMatrixReduction( MetricAnIso M1,  MetricAnIso M2,D2xD2 &V);
+	void  SimultaneousMatrixReduction( Metric M1,  Metric M2,D2xD2 &V);
 
-	inline MetricAnIso::MetricAnIso(const MatVVP2x2 M) {
+	inline Metric::Metric(const MatVVP2x2 M) {
 		//     recompose M in: M = V^t lambda V 
 		//     V = ( v,v^\perp)
@@ -136,5 +99,5 @@
 	  }
 
-	inline   void  MetricAnIso::Box(Real4 &hx,Real4 &hy) const {
+	inline   void  Metric::Box(Real4 &hx,Real4 &hy) const {
 		Real8 d=  a11*a22-a21*a21;
 		hx = sqrt(a22/d);
@@ -142,15 +105,7 @@
 	}
 
-	inline MetricIso::MetricIso(const MetricAnIso M) 
-	  {MatVVP2x2 vp(M);h=1/sqrt(Max(vp.lambda1,vp.lambda2));}
-
-	inline  MetricIso::MetricIso(Real8 a11,Real8 a21,Real8 a22)
-	  {MatVVP2x2 vp(MetricAnIso(a11,a21,a22));h=1/sqrt(Max(vp.lambda1,vp.lambda2));}
-
-
-
 	class SaveMetricInterpole {
-		friend Real8 LengthInterpole(const MetricAnIso ,const  MetricAnIso , R2 );
-		friend Real8 abscisseInterpole(const MetricAnIso ,const  MetricAnIso , R2 ,Real8 ,int );
+		friend Real8 LengthInterpole(const Metric ,const  Metric , R2 );
+		friend Real8 abscisseInterpole(const Metric ,const  Metric , R2 ,Real8 ,int );
 		int opt;
 		Real8 lab;
@@ -160,6 +115,6 @@
 	extern SaveMetricInterpole  LastMetricInterpole; // for optimization 
 
-	Real8 LengthInterpole(const MetricAnIso Ma,const  MetricAnIso Mb, R2 AB);
-	Real8 abscisseInterpole(const MetricAnIso Ma,const  MetricAnIso Mb, R2 AB,Real8 s,int optim=0);
+	Real8 LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB);
+	Real8 abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,Real8 s,int optim=0);
 
 	inline Real8 LengthInterpole(Real8 la,Real8 lb) 
Index: /issm/trunk/src/c/Bamgx/QuadTree.h
===================================================================
--- /issm/trunk/src/c/Bamgx/QuadTree.h	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/QuadTree.h	(revision 2981)
@@ -6,5 +6,5 @@
 
 	const int MaxDeep = 30;
-	typedef  long  IntQuad;
+	typedef long IntQuad;
 	//long int 1, bitwise operation: 8L = 00001000 << 2L -> 00100000 shifted left by 2
 	const IntQuad MaxISize = ( 1L << MaxDeep); 
@@ -16,11 +16,11 @@
 				public:
 					long n; 
+					//contains only one object form the list (either Vertex or QuadTreeBox)
+					// if n < 4 => Vertex else =>  QuadTreeBox;
 					union{
-						//contains only one object form the list (either Vertex or QuadTreeBox)
-						// if n < 4 => Vertex else =>  QuadTreeBox;
 						QuadTreeBox* b[4];
 						Vertex* v[4];
 					};
-			}; // end class
+			};
 			class StorageQuadTreeBox {
 				public:
@@ -34,18 +34,25 @@
 					}
 					long  SizeOf() const {return len*sizeof(QuadTreeBox)+sizeof(StorageQuadTreeBox)+ (n?n->SizeOf():0);}
-			}; // end class
+			};
 			StorageQuadTreeBox* sb;
-			long  lenStorageQuadTreeBox;
+			long                lenStorageQuadTreeBox;
 
 		public:
+
+			//fields
 			QuadTreeBox* root;
-			Triangles* th;
-			long NbQuadTreeBox,NbVertices;
-			long NbQuadTreeBoxSearch,NbVerticesSearch;
+			Triangles*   th;
+
+			//functions
+			~QuadTree();
+			QuadTree(Triangles * t,long nbv=-1);
+			QuadTree();
+			long    NbQuadTreeBox,NbVertices;
+			long    NbQuadTreeBoxSearch,NbVerticesSearch;
 			Vertex* NearestVertex(Icoor1 i,Icoor1 j);
-			Vertex*  NearestVertexWithNormal(Icoor1 i,Icoor1 j);
+			Vertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
 			Vertex* ToClose(Vertex & ,Real8 ,Icoor1,Icoor1);
-			long SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();}
-			void  Add( Vertex & w);
+			long    SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();}
+			void    Add( Vertex & w);
 			QuadTreeBox* NewQuadTreeBox(){
 				if(! (sb->bc<sb->be)) sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
@@ -54,7 +61,4 @@
 				return sb->bc++;
 			}
-			~QuadTree();
-			QuadTree(Triangles * t,long nbv=-1);
-			QuadTree();
 	};
 }
Index: /issm/trunk/src/c/Bamgx/R2.h
===================================================================
--- /issm/trunk/src/c/Bamgx/R2.h	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/R2.h	(revision 2981)
@@ -1,5 +1,5 @@
 namespace bamg {
+
 	template <class R,class RR> class P2xP2;
-
 	template <class R,class RR>
 	  class P2 {
@@ -15,25 +15,25 @@
 			  P2 (R a,R b)  :x(a),y(b)  {}
 			  P2 (P2 A,P2 B) : x(B.x-A.x),y(B.y-A.y) {}
-			  P2<R,RR>   operator+(const P2<R,RR> & cc) const {return P2<R,RR>(x+cc.x,y+cc.y);}
-			  P2<R,RR>   operator-(const P2<R,RR> & cc) const {return P2<R,RR>(x-cc.x,y-cc.y);}
-			  P2<R,RR>   operator-()  const{return P2<R,RR>(-x,-y);}
-			  RR   operator,(const P2<R,RR> & cc) const {return  (RR) x* (RR) cc.x+(RR) y* (RR) cc.y;} // produit scalaire
-			  P2<R,RR>   operator*(R  cc) const {return P2<R,RR>(x*cc,y*cc);}
-			  P2<R,RR>   operator/(R  cc) const {return P2<R,RR>(x/cc,y/cc);}
-			  P2<R,RR>  operator+=(const  P2<R,RR> & cc) {x += cc.x;y += cc.y;return *this;}
-			  P2<R,RR>  operator/=(const  R r) {x /= r;y /= r;return *this;}
-			  P2<R,RR>  operator*=(const  R r) {x *= r;y *= r;return *this;}
-			  P2<R,RR>  operator-=(const  P2<R,RR> & cc) {x -= cc.x;y -= cc.y;return *this;}
+			  RR       operator,(const P2<R,RR> & cc) const {return  (RR) x* (RR) cc.x+(RR) y* (RR) cc.y;} //scalar product
+			  P2<R,RR> operator+(const P2<R,RR> & cc) const {return P2<R,RR>(x+cc.x,y+cc.y);}
+			  P2<R,RR> operator-(const P2<R,RR> & cc) const {return P2<R,RR>(x-cc.x,y-cc.y);}
+			  P2<R,RR> operator-()  const{return P2<R,RR>(-x,-y);}
+			  P2<R,RR> operator*(R  cc) const {return P2<R,RR>(x*cc,y*cc);}
+			  P2<R,RR> operator/(R  cc) const {return P2<R,RR>(x/cc,y/cc);}
+			  P2<R,RR> operator+=(const  P2<R,RR> & cc) {x += cc.x;y += cc.y;return *this;}
+			  P2<R,RR> operator/=(const  R r) {x /= r;y /= r;return *this;}
+			  P2<R,RR> operator*=(const  R r) {x *= r;y *= r;return *this;}
+			  P2<R,RR> operator-=(const  P2<R,RR> & cc) {x -= cc.x;y -= cc.y;return *this;}
 	  };
 
 	template <class R,class RR>
-	  class P2xP2 { // x ligne 1 y ligne2 
-
-		  friend P2<R,RR> operator*(P2<R,RR> c,P2xP2<R,RR> cc)
-			 {return P2<R,RR>(c.x*cc.x.x + c.y*cc.y.x, c.x*cc.x.y + c.y*cc.y.y);} 
-
-
+	  class P2xP2 {
+		  friend P2<R,RR> operator*(P2<R,RR> c,P2xP2<R,RR> cc){
+			  return P2<R,RR>(c.x*cc.x.x + c.y*cc.y.x, c.x*cc.x.y + c.y*cc.y.y);
+		  } 
 		  public:
 		  P2<R,RR> x,y; 
+
+		  //functions
 		  void Echo(){
 			  printf("Member of P2xP2:\n");
@@ -45,47 +45,57 @@
 		  P2xP2 (P2<R,RR> a,P2<R,RR> b,P2<R,RR> c ): x(b-a),y(c-a) {}
 		  P2xP2 (R xx,R xy,R yx,R yy) :x(xx,xy),y(yx,yy) {}
-		  P2<R,RR> operator*(const P2<R,RR> c) const {return P2<R,RR>(x.x*c.x + x.y*c.y, y.x*c.x + y.y*c.y);}
-		  P2xP2<R,RR>  operator*(P2xP2<R,RR> c) const 
-			 { return  P2xP2<R,RR>(x.x*c.x.x + x.y*c.y.x,
+		  RR          det() const {return (RR) x.x* (RR) y.y - (RR) x.y * (RR) y.x;}
+		  P2xP2<R,RR> inv()  const{
+			  RR d = (*this).det(); 
+			  return P2xP2<R,RR>((R)( y.y /d) ,(R)(-x.y/d),(R)( -y.x/d) ,(R)( x.x/d) );
+			 };
+		  P2xP2<R,RR> t()  {return P2xP2<R,RR>(x.x,y.x,x.y,y.y);} //transposer 
+		  P2<R,RR>    tx() {return P2<R,RR>(x.x,y.x);} 
+		  P2<R,RR>    ty() {return P2<R,RR>(x.y,y.y);} 
+
+		  //Operators
+		  P2<R,RR>     operator*(const P2<R,RR> c) const {return P2<R,RR>(x.x*c.x + x.y*c.y, y.x*c.x + y.y*c.y);}
+		  P2xP2<R,RR>  operator*(P2xP2<R,RR> c) const{
+			  return  P2xP2<R,RR>(x.x*c.x.x + x.y*c.y.x,
 						 x.x*c.x.y + x.y*c.y.y,
 						 y.x*c.x.x + y.y*c.y.x,
-						 y.x*c.x.y + y.y*c.y.y);}
-		  RR det() const {return (RR) x.x* (RR) y.y - (RR) x.y * (RR) y.x;}
-		  P2xP2<R,RR> inv()  const
-			 { RR d = (*this).det(); 
-			  return P2xP2<R,RR>((R)( y.y /d) ,(R)(-x.y/d),(R)( -y.x/d) ,(R)( x.x/d) );
-			 };
-		  P2xP2<R,RR> t() {return P2xP2<R,RR>(x.x,y.x,x.y,y.y);} //transposer 
-		  P2<R,RR>tx() {return P2<R,RR>(x.x,y.x);} 
-		  P2<R,RR>ty() {return P2<R,RR>(x.y,y.y);} 
-
+						 y.x*c.x.y + y.y*c.y.y);
+		  }
 	  };  
 
+	//inline functions
 	template  <class R,class RR>  
 	  inline RR Det(const P2<R,RR> x,const P2<R,RR> y) {
-		  return (RR) x.x * (RR) y.y - (RR) x.y * (RR) y.x ;} 
+		  return (RR) x.x * (RR) y.y - (RR) x.y * (RR) y.x ;
+	  } 
 
 	template  <class R,class RR>  
 	  inline RR Area2 (const P2<R,RR> a,const P2<R,RR> b,const P2<R,RR> c) {
-		  return Det(b-a,c-a) ;} 
+		  return Det(b-a,c-a) ;
+	  }
 
 	template  <class R,class RR>  
 	  inline R Norme1 (const P2<R,RR> x) {
-		  return (Abs(x.x)+Abs(x.y)) ;} 
+		  return (Abs(x.x)+Abs(x.y)) ;
+	  } 
 
 	template  <class R,class RR>  
 	  inline R NormeInfini (const P2<R,RR> x) {
-		  return Max(Abs(x.x),Abs(x.y)) ;} 
+		  return Max(Abs(x.x),Abs(x.y)) ;
+	  }
 
 	template  <class R,class RR>  
 	  inline RR Norme2_2 (const P2<R,RR> x) {
-		  return (RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y ;} 
+		  return (RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y ;
+	  } 
 
 	template  <class R,class RR>  
 	  inline RR Norme2 (const P2<R,RR> x) {
-		  return sqrt((RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y) ;} 
+		  return sqrt((RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y) ;
+	  } 
 
 	template  <class R,class RR>  
 	  inline P2<R,RR> Orthogonal (const P2<R,RR> x) {
-		  return  P2<R,RR>(-x.y,x.x);} 
+		  return  P2<R,RR>(-x.y,x.x);
+	  } 
 }
Index: /issm/trunk/src/c/Bamgx/SetOfE4.h
===================================================================
--- /issm/trunk/src/c/Bamgx/SetOfE4.h	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/SetOfE4.h	(revision 2981)
@@ -4,5 +4,6 @@
 namespace bamg {
 
-	class SetOfEdges4 ;
+	class SetOfEdges4;
+
 	class Int4Edge{
 		friend class SetOfEdges4;
@@ -28,4 +29,6 @@
 		Int4 j(Int4 k){return Edges[k].j;}
 		Int4 newarete(Int4 k){return NbOfEdges == k+1;}
+
+		//operators
 		Int4Edge & operator[](Int4 k){return  Edges[k];}
 	};
Index: /issm/trunk/src/c/Bamgx/objects/MatVVP2x2.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/MatVVP2x2.cpp	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/objects/MatVVP2x2.cpp	(revision 2981)
@@ -18,6 +18,6 @@
 
 	/*Constructor*/
-	/*FUNCTION MatVVP2x2::MatVVP2x2(const MetricAnIso M){{{1*/
-	MatVVP2x2::MatVVP2x2(const MetricAnIso M){
+	/*FUNCTION MatVVP2x2::MatVVP2x2(const Metric M){{{1*/
+	MatVVP2x2::MatVVP2x2(const Metric M){
 		double a11=M.a11,a21=M.a21,a22=M.a22;
 		const double eps = 1.e-5;
Index: /issm/trunk/src/c/Bamgx/objects/MetricAnIso.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/MetricAnIso.cpp	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/objects/MetricAnIso.cpp	(revision 2981)
@@ -13,5 +13,5 @@
 
 #undef __FUNCT__ 
-#define __FUNCT__ "MetricAnIso"
+#define __FUNCT__ "Metric"
 
 using namespace std;
@@ -22,7 +22,7 @@
 
 	/*Constructor/Destructor*/
-	/*FUNCTION MetricAnIso::MetricAnIso(const Real8  a[3],const  MetricAnIso m0, const  MetricAnIso m1,const  MetricAnIso  m2 ){{{1*/ 
-	MetricAnIso::MetricAnIso(const Real8  a[3],const  MetricAnIso m0, const  MetricAnIso m1,const  MetricAnIso m2 ){
-		MetricAnIso mab(a[0]*m0.a11 + a[1]*m1.a11 + a[2]*m2.a11,
+	/*FUNCTION Metric::Metric(const Real8  a[3],const  Metric m0, const  Metric m1,const  Metric  m2 ){{{1*/ 
+	Metric::Metric(const Real8  a[3],const  Metric m0, const  Metric m1,const  Metric m2 ){
+		Metric mab(a[0]*m0.a11 + a[1]*m1.a11 + a[2]*m2.a11,
 					a[0]*m0.a21 + a[1]*m1.a21 + a[2]*m2.a21,
 					a[0]*m0.a22 + a[1]*m1.a22 + a[2]*m2.a22);
@@ -41,7 +41,7 @@
 	}
 	/*}}}1*/
-	/*FUNCTION MetricAnIso::MetricAnIso( Real8  a,const  MetricAnIso ma, Real8  b,const  MetricAnIso mb){{{1*/
-	MetricAnIso::MetricAnIso( Real8  a,const  MetricAnIso ma, Real8  b,const  MetricAnIso mb) { 
-		MetricAnIso mab(a*ma.a11+b*mb.a11,a*ma.a21+b*mb.a21,a*ma.a22+b*mb.a22);
+	/*FUNCTION Metric::Metric( Real8  a,const  Metric ma, Real8  b,const  Metric mb){{{1*/
+	Metric::Metric( Real8  a,const  Metric ma, Real8  b,const  Metric mb) { 
+		Metric mab(a*ma.a11+b*mb.a11,a*ma.a21+b*mb.a21,a*ma.a22+b*mb.a22);
 		MatVVP2x2 vab(mab);
 
@@ -59,9 +59,9 @@
 
 	/*Methods*/
-	/*FUNCTION MetricAnIso::Echo {{{1*/
-
-	void MetricAnIso::Echo(void){
-
-		printf("MetricAnIso:\n");
+	/*FUNCTION Metric::Echo {{{1*/
+
+	void Metric::Echo(void){
+
+		printf("Metric:\n");
 		printf("   [a11 a21 a22]: [%g %g %g]\n",a11,a21,a22);
 
@@ -69,6 +69,6 @@
 	}
 	/*}}}*/
-	/*FUNCTION MetricAnIso::IntersectWith{{{1*/
-	int MetricAnIso::IntersectWith(const MetricAnIso M2) {
+	/*FUNCTION Metric::IntersectWith{{{1*/
+	int Metric::IntersectWith(const Metric M2) {
 		/*Get a new metric from an existing metric (M1=this)
 		 * and a new metric given in input M2 using a 
@@ -88,5 +88,5 @@
 
 		int         change=0;
-		MetricAnIso &M1=*this;
+		Metric &M1=*this;
 		D2xD2       P;
 
@@ -123,5 +123,5 @@
 	/*Intermediary*/
 	/*FUNCTION LengthInterpole{{{1*/
-	Real8 LengthInterpole(const MetricAnIso Ma,const  MetricAnIso Mb, R2 AB) {
+	Real8 LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB) {
 		Real8 k=1./2.;
 		int level=0;
@@ -189,5 +189,5 @@
 	/*}}}1*/
 	/*FUNCTION SimultaneousMatrixReduction{{{1*/
-	void SimultaneousMatrixReduction( MetricAnIso M1,  MetricAnIso M2, D2xD2 &V) {
+	void SimultaneousMatrixReduction( Metric M1,  Metric M2, D2xD2 &V) {
 		/*In this routine we must return a matrix V that is composed of the 
 		 * eigen vectors of N=inv(M1) M2.
@@ -292,5 +292,5 @@
 	/*}}}1*/
 	/*FUNCTION abscisseInterpole{{{1*/
-	Real8 abscisseInterpole(const MetricAnIso Ma,const  MetricAnIso Mb, R2 AB,Real8 s,int optim) { 
+	Real8 abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,Real8 s,int optim) { 
 		if(!optim)  LengthInterpole(Ma,Mb,AB);
 		Real8 l  = s* LastMetricInterpole.lab,r;
Index: /issm/trunk/src/c/Bamgx/objects/Triangles.cpp
===================================================================
--- /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 2980)
+++ /issm/trunk/src/c/Bamgx/objects/Triangles.cpp	(revision 2981)
@@ -773,5 +773,5 @@
 					b=bamgopts->metric[i*3+1];
 					c=bamgopts->metric[i*3+2];
-					MetricAnIso M(a,b,c);
+					Metric M(a,b,c);
 					MatVVP2x2 Vp(M/coef);
 
@@ -3834,5 +3834,5 @@
 					D2xD2 D(maxsubdiv2,0,0,lc);
 					D2xD2 MM = Rt1*D*Rt1.t();
-					v0.m =  M = MetricAnIso(MM.x.x,MM.y.x,MM.y.y);
+					v0.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
 					nbchange++;
 				  }
@@ -3847,5 +3847,5 @@
 					D2xD2 D(maxsubdiv2,0,0,lc);
 					D2xD2  MM = Rt1*D*Rt1.t();
-					v1.m =  M = MetricAnIso(MM.x.x,MM.y.x,MM.y.y);
+					v1.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
 					nbchange++;
 				  }
@@ -4431,5 +4431,5 @@
 		 D2xD2 BK =  B_K*B1r;
 		 D2xD2 B1B1 = B1K.t()*B1K;
-		 MetricAnIso MK(B1B1.x.x,B1B1.x.y,B1B1.y.y);
+		 Metric MK(B1B1.x.x,B1B1.x.y,B1B1.y.y);
 		 MatVVP2x2 VMK(MK);
 		 alpha2 = Max(alpha2,Max(VMK.lambda1/VMK.lambda2,VMK.lambda2/VMK.lambda1));
@@ -4442,9 +4442,9 @@
 			 hmax=Max(hmax,he);
 			 Vertex & v=K[j];
-			 D2xD2 M((MetricAnIso)v);
+			 D2xD2 M((Metric)v);
 			 betaK += sqrt(M.det());
 
 			 D2xD2 BMB = BK.t()*M*BK;
-			 MetricAnIso M1(BMB.x.x,BMB.x.y,BMB.y.y);
+			 Metric M1(BMB.x.x,BMB.x.y,BMB.y.y);
 			 MatVVP2x2 VM1(M1);
 			 gammamn=Min3(gammamn,VM1.lambda1,VM1.lambda2);