diff --git a/Fltk/visibilityWindow.cpp b/Fltk/visibilityWindow.cpp
index 59864b9ad872ab9c9d0e8a4f9e5b8568fc463356..e310b90c4222a66a74f3d22cab45fb7c293e69b2 100644
--- a/Fltk/visibilityWindow.cpp
+++ b/Fltk/visibilityWindow.cpp
@@ -249,7 +249,7 @@ class VisibilityList { // singleton
       }
     }
     else if(type == MeshPartitions){
-      for(int part = 0; part < m->getNumPartitions(); part++)
+      for(unsigned int part = 0; part < m->getNumPartitions(); part++)
         _entities.push_back(new VisPartition(part + 1));
     }
     std::sort(_entities.begin(), _entities.end(), VisLessThan());
diff --git a/Geo/MElementCut.cpp b/Geo/MElementCut.cpp
index bcafddc9b8e463e5f23ab608ea0c9f041469976a..624f887427374ee468498bd49fec3f19be7213d4 100644
--- a/Geo/MElementCut.cpp
+++ b/Geo/MElementCut.cpp
@@ -1515,7 +1515,9 @@ GModel *buildCutMesh(GModel *gm, gLevelset *ls,
         elementSplitMesh(e, RPN, verticesLs, gmEntities[i], gm, numEle, vertexMap,
                          newParents, newDomains, elements, physicals, newElemTags,
                          newPhysTags, borderElemTags, borderPhysTags);
-        if(e->getPartition() > cutGM->getNumPartitions()) cutGM->setNumPartitions(e->getPartition());
+        if(e->getPartition() > static_cast<int>(cutGM->getNumPartitions())) {
+            cutGM->setNumPartitions(e->getPartition());
+        }
       }
     }
     return cutGM;
@@ -1545,7 +1547,9 @@ GModel *buildCutMesh(GModel *gm, gLevelset *ls,
                      newVertices, newParents, newDomains, borders, elements, physicals,
                      newElemTags, newPhysTags, borderElemTags, borderPhysTags, cp,
                      lines, triangles, quads, tetras, hexas);
-      if(e->getPartition() > cutGM->getNumPartitions()) cutGM->setNumPartitions(e->getPartition());
+      if(e->getPartition() > static_cast<int>(cutGM->getNumPartitions())) {
+          cutGM->setNumPartitions(e->getPartition());
+      }
     }
 
     // Create elementary and physical for non connected border lines
diff --git a/Geo/MElementOctree.cpp b/Geo/MElementOctree.cpp
index c49ba2d28b83c8b4f958dc4fee6fb41ee57c7449..3f61ef826af07b223da0b70885c5da9e41904415 100644
--- a/Geo/MElementOctree.cpp
+++ b/Geo/MElementOctree.cpp
@@ -42,7 +42,7 @@ void MElementBB(void *a, double *min, double *max)
     min[0] = max[0] = bezNodes(0, 0);
     min[1] = max[1] = bezNodes(0, 1);
     min[2] = max[2] = bezNodes(0, 2);
-    for(int i = 1; i < e->getNumVertices(); i++) {
+    for(MElement::size_type i = 1; i < e->getNumVertices(); i++) {
       min[0] = std::min(min[0], bezNodes(i, 0));
       max[0] = std::max(max[0], bezNodes(i, 0));
       min[1] = std::min(min[1], bezNodes(i, 1));
@@ -120,8 +120,8 @@ MElementOctree::MElementOctree(GModel *m) : _gm(m)
 MElementOctree::MElementOctree(const std::vector<MElement*> &v) : _gm(0), _elems(v)
 {
   SBoundingBox3d bb;
-  for (unsigned int i = 0; i < v.size(); i++){
-    for(int j = 0; j < v[i]->getNumVertices(); j++){
+  for (MElement::size_type i = 0; i < v.size(); i++){
+    for(MElement::size_type j = 0; j < v[i]->getNumVertices(); j++){
       //if (!_gm) _gm = v[i]->getVertex(j)->onWhat()->model();
       bb += SPoint3(v[i]->getVertex(j)->x(),
                     v[i]->getVertex(j)->y(),
diff --git a/Geo/MVertex.h b/Geo/MVertex.h
index 79ec6734f221d223b1f878fb614ae1363210cda0..584b60cb313edb21fd834e9d756845f9edff130c 100644
--- a/Geo/MVertex.h
+++ b/Geo/MVertex.h
@@ -38,6 +38,9 @@ class MVertex{
   // the geometrical entity the vertex is associated with
   GEntity *_ge;
 
+public:
+  typedef std::vector<int>::size_type size_type;
+
  public:
   MVertex(double x, double y, double z, GEntity *ge=0, int num=0);
   virtual ~MVertex(){}
@@ -48,34 +51,34 @@ class MVertex{
   virtual void setVisibility(char val){ _visible = val; }
 
   // get the "polynomial order" of the vertex
-  inline int getPolynomialOrder(){ return _order; }
-  inline void setPolynomialOrder(int order){ _order = (char)order; }
+  int getPolynomialOrder(){ return _order; }
+  void setPolynomialOrder(int order){ _order = (char)order; }
 
   // get/set the coordinates
-  inline double x() const { return _x; }
-  inline double y() const { return _y; }
-  inline double z() const { return _z; }
-  inline double & x() { return _x; }
-  inline double & y() { return _y; }
-  inline double & z() { return _z; }
+  double x() const { return _x; }
+  double y() const { return _y; }
+  double z() const { return _z; }
+  double & x() { return _x; }
+  double & y() { return _y; }
+  double & z() { return _z; }
 
-  inline SPoint3 point() const { return SPoint3(_x, _y, _z); }
-  inline void setXYZ(double x, double y, double z) { _x = x; _y = y; _z = z; }
+  SPoint3 point() const { return SPoint3(_x, _y, _z); }
+  void setXYZ(double x, double y, double z) { _x = x; _y = y; _z = z; }
 
   // get/set the parent entity
-  inline GEntity* onWhat() const { return _ge; }
-  inline void setEntity(GEntity *ge) { _ge = ge; }
+  GEntity* onWhat() const { return _ge; }
+  void setEntity(GEntity *ge) { _ge = ge; }
 
   // get the immutab vertex number
-  inline int getNum() const { return _num; }
+  int getNum() const { return _num; }
 
   // force the immutable number (this should never be used, except when
   // explicitly renumbering the mesh)
   void forceNum(int num);
 
   // get/set the index
-  inline int getIndex() const { return _index; }
-  inline void setIndex(int index) { _index = index; }
+  int getIndex() const { return _index; }
+  void setIndex(int index) { _index = index; }
 
 
   // get/set ith parameter
@@ -83,12 +86,12 @@ class MVertex{
   virtual bool setParameter(int i, double par){ return false; }
 
   // measure distance to another vertex
-  double distance(MVertex *v)
+  double distance(MVertex *const v)
   {
     double dx = _x - v->x();
     double dy = _y - v->y();
     double dz = _z - v->z();
-    return sqrt(dx * dx + dy * dy + dz * dz);
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
   }
 
   // IO routines
@@ -181,7 +184,7 @@ inline double distance (MVertex *v1, MVertex *v2)
   const double dx = v1->x() - v2->x();
   const double dy = v1->y() - v2->y();
   const double dz = v1->z() - v2->z();
-  return sqrt(dx*dx+dy*dy+dz*dz);
+  return std::sqrt(dx*dx+dy*dy+dz*dz);
 }
 
 #endif
diff --git a/Graphics/drawMesh.cpp b/Graphics/drawMesh.cpp
index a125bc155e0c6aa71482be05be608a057fd0feb2..8e17819d84fe6668cf1eb7c487f91e2ced6ae6dd 100644
--- a/Graphics/drawMesh.cpp
+++ b/Graphics/drawMesh.cpp
@@ -202,7 +202,7 @@ static void drawVerticesPerElement(drawContext *ctx, GEntity *e,
 {
   for(unsigned int i = 0; i < elements.size(); i++){
     MElement *ele = elements[i];
-    for(int j = 0; j < ele->getNumVertices(); j++){
+    for(MElement::size_type j = 0; j < ele->getNumVertices(); j++){
       MVertex *v = ele->getVertex(j);
       // FIXME isElementVisible() can be slow: we should also use a
       // vertex array for drawing vertices...
@@ -262,7 +262,7 @@ static void drawBarycentricDual(std::vector<T*> &elements)
         SPoint3 p = f.barycenter();
         glVertex3d(pc.x(), pc.y(), pc.z());
         glVertex3d(p.x(), p.y(), p.z());
-        for(int k = 0; k < f.getNumVertices(); k++){
+        for(typename T::size_type k = 0; k < f.getNumVertices(); k++){
           MEdge e(f.getVertex(k), (k == f.getNumVertices() - 1) ?
                   f.getVertex(0) : f.getVertex(k + 1));
           SPoint3 pe = e.barycenter();
@@ -312,7 +312,7 @@ static void drawVoronoiDual(std::vector<T*> &elements)
         SPoint3 p = f.barycenter();
         glVertex3d(pc.x(), pc.y(), pc.z());
         glVertex3d(p.x(), p.y(), p.z());
-        for(int k = 0; k < f.getNumVertices(); k++){
+        for(typename T::size_type k = 0; k < f.getNumVertices(); k++){
           MEdge e(f.getVertex(k), (k == f.getNumVertices() - 1) ?
                   f.getVertex(0) : f.getVertex(k + 1));
           SPoint3 pe = e.barycenter();
diff --git a/Mesh/BackgroundMesh2D.cpp b/Mesh/BackgroundMesh2D.cpp
index 217914b4e8c2d85f928fc98fa7f5f040d15031af..ac491312de1bdfde8b407cc3b1489019365c6434 100644
--- a/Mesh/BackgroundMesh2D.cpp
+++ b/Mesh/BackgroundMesh2D.cpp
@@ -579,9 +579,9 @@ void frameFieldBackgroundMesh2D::computeSmoothness()
   std::multimap<MVertex*,MVertex*> vertex2vertex;
   for (std::vector<MElement*>::iterator it = beginelements();it!=endelements();it++){
     MElement *e = *it;
-    for (int i=0;i<e->getNumVertices();i++){
+    for (MElement::size_type i=0;i<e->getNumVertices();i++){
       MVertex *current = e->getVertex(i);
-      for (int j=0;j<e->getNumVertices();j++){
+      for (MVertex::size_type j=0;j<e->getNumVertices();j++){
         if (i==j) continue;
         MVertex *neighbor = e->getVertex(j);
         vertex2vertex.insert(std::make_pair(current,neighbor));
diff --git a/Mesh/QuadTriExtruded2D.cpp b/Mesh/QuadTriExtruded2D.cpp
index eb47d63440a4e345aecd99c6bcb0a693a5e2d3cf..9416bb8b6b73f62d740bff386b8a95f330bca579 100644
--- a/Mesh/QuadTriExtruded2D.cpp
+++ b/Mesh/QuadTriExtruded2D.cpp
@@ -372,7 +372,7 @@ static int MeshQuadToTriTopUnstructured(GFace *from, GFace *to, MVertexRTree &po
 
   for(unsigned int i = 0; i < from->quadrangles.size(); i++){
     std::vector<MVertex*> verts;
-    for(int j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+    for(MVertex::size_type j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
       MVertex *v = from->quadrangles[i]->getVertex(j);
       double x = v->x(), y = v->y(), z = v->z();
       ExtrudeParams *ep = to->meshAttributes.extrude;
@@ -467,7 +467,7 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
     // loop through each element source quadrangle and extrude
     for(unsigned int i = 0; i < from->quadrangles.size(); i++){
       std::vector<MVertex*> verts;
-      for(int j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+      for(MVertex::size_type j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
         MVertex *v = from->quadrangles[i]->getVertex(j);
         double x = v->x(), y = v->y(), z = v->z();
         ExtrudeParams *ep = to->meshAttributes.extrude;
@@ -498,7 +498,7 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
       int edge_verts_count = 0;
       //int skip_index = 0;
       int bnd_indices[4];
-      for(int p = 0; p < element->getNumVertices(); p++){
+      for(MElement::size_type p = 0; p < element->getNumVertices(); p++){
         if(pos_src_edge.find(element->getVertex(p)->x(),
                              element->getVertex(p)->y(),
                              element->getVertex(p)->z())){
@@ -560,7 +560,7 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
     // quite easily. Loop through each element source quadrangle and extrude
     for(unsigned int i = 0; i < from->quadrangles.size(); i++){
       std::vector<MVertex*> verts;
-      for(int j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+      for(MElement::size_type j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
         MVertex *v = from->quadrangles[i]->getVertex(j);
         double x = v->x(), y = v->y(), z = v->z();
         ExtrudeParams *ep = to->meshAttributes.extrude;
diff --git a/Mesh/ThinLayer.cpp b/Mesh/ThinLayer.cpp
index 346e08c48a654f4abb4aa0c196313142ee7cd95e..4193208c218844ad7fdcaab3571bc6f73887237e 100644
--- a/Mesh/ThinLayer.cpp
+++ b/Mesh/ThinLayer.cpp
@@ -169,7 +169,7 @@ void ThinLayer::fillvecOfThinSheets(){
           MVertex* VToDo = (*CurrentSheet.begin());
           std::vector<MTetrahedron*> surroundingTet = VertexToTets[VToDo];
           for (unsigned int j = 0;j < surroundingTet.size();j++){
-            for (int k = 0;k < surroundingTet[j]->getNumVertices();k++){
+            for (MVertex::size_type k = 0;k < surroundingTet[j]->getNumVertices();k++){
               MVertex* ToInsertTmp = surroundingTet[j]->getVertex(k);
               std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it2 =
                 VertexToCorresp.find(ToInsertTmp);
diff --git a/Mesh/Voronoi3D.cpp b/Mesh/Voronoi3D.cpp
index 9f139272a49f5898dfdc9ba462c3427968835b45..ad806187aa1416ee64725a617e2ac1a7d7ba7a0d 100644
--- a/Mesh/Voronoi3D.cpp
+++ b/Mesh/Voronoi3D.cpp
@@ -41,33 +41,33 @@ void clip::execute(){
 }
 
 void clip::execute(GRegion* gr){
-  unsigned int i;
-  int j;
-  MElement* element;
-  MVertex* vertex;
-  std::vector<SPoint3> vertices2;
+
   std::set<MVertex*> vertices;
   std::set<MVertex*>::iterator it;
-  std::vector<VoronoiElement> clipped;
 
-  for(i=0;i<gr->getNumMeshElements();i++){
-    element = gr->getMeshElement(i);
-	for(j=0;j<element->getNumVertices();j++){
-	  vertex = element->getVertex(j);
+  for(MVertex::size_type i=0;i<gr->getNumMeshElements();i++){
+    MElement* element = gr->getMeshElement(i);
+	for(MVertex::size_type j=0;j<element->getNumVertices();j++){
+	  MVertex* vertex = element->getVertex(j);
 	  vertices.insert(vertex);
 	}
   }
 
+  std::vector<SPoint3> vertices2;
+  vertices2.reserve(vertices.size());
+
   for(it=vertices.begin();it!=vertices.end();it++){
     vertices2.push_back(SPoint3((*it)->x(),(*it)->y(),(*it)->z()));
   }
 
+  std::vector<VoronoiElement> clipped;
   execute(vertices2,clipped);
+
   printf("%d\n", (int)clipped.size());
 
   std::ofstream file("MicrostructurePolycrystal3D.pos");
   file << "View \"test\" {\n";
-  for(i=0;i<clipped.size();i++){
+  for(MVertex::size_type i=0;i<clipped.size();i++){
     print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v2().get_point(),file);
 	print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v3().get_point(),file);
 	print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v4().get_point(),file);
diff --git a/Mesh/directions3D.cpp b/Mesh/directions3D.cpp
index a9888119c60415442988e6c862439a8f716a8934..84a73f14d022212ef057d5bf02c278540e7f98cc 100644
--- a/Mesh/directions3D.cpp
+++ b/Mesh/directions3D.cpp
@@ -273,49 +273,38 @@ void Frame_field::print_field2(GRegion* gr)
 {
   // Saves a file with the cross fields inside the given GRegion, excluding the
   // boundary.
-  unsigned int i;
-  int j;
-  double k;
-  double color1;
-  double color2;
-  SPoint3 point;
-  SPoint3 p1,p2,p3,p4,p5,p6;
-  MVertex* vertex;
-  MElement* element;
-  STensor3 m(1.0);
-
-  k = 0.05;
+  double const k = 0.05;
   std::ofstream file("frame2.pos");
   file << "View \"cross field\" {\n";
-  color1 = 10.0;
-  color2 = 20.0;
+  double const color1 = 10.0;
+  double const color2 = 20.0;
 
-  for(i=0;i<gr->getNumMeshElements();i++){
-    element = gr->getMeshElement(i);
-    for(j=0;j<element->getNumVertices();j++){
-      vertex = element->getVertex(j);
+  for(MVertex::size_type i=0;i<gr->getNumMeshElements();i++){
+    MElement* element = gr->getMeshElement(i);
+    for(MVertex::size_type j=0;j<element->getNumVertices();j++){
+      MVertex* vertex = element->getVertex(j);
       if(vertex->onWhat()->dim()>2){
-        point = SPoint3(vertex->x(),vertex->y(),vertex->z());
-        m = search(vertex->x(),vertex->y(),vertex->z());
-
-        p1 = SPoint3(point.x() + k*m.get_m11(),
-                     point.y() + k*m.get_m21(),
-                     point.z() + k*m.get_m31());
-        p2 = SPoint3(point.x() - k*m.get_m11(),
-                     point.y() - k*m.get_m21(),
-                     point.z() - k*m.get_m31());
-        p3 = SPoint3(point.x() + k*m.get_m12(),
-                     point.y() + k*m.get_m22(),
-                     point.z() + k*m.get_m32());
-        p4 = SPoint3(point.x() - k*m.get_m12(),
-                     point.y() - k*m.get_m22(),
-                     point.z() - k*m.get_m32());
-        p5 = SPoint3(point.x() + k*m.get_m13(),
-                     point.y() + k*m.get_m23(),
-                     point.z() + k*m.get_m33());
-        p6 = SPoint3(point.x() - k*m.get_m13(),
-                     point.y() - k*m.get_m23(),
-                     point.z() - k*m.get_m33());
+        SPoint3 point = SPoint3(vertex->x(),vertex->y(),vertex->z());
+        STensor3 m = search(vertex->x(),vertex->y(),vertex->z());
+
+        SPoint3 p1(point.x() + k*m.get_m11(),
+                   point.y() + k*m.get_m21(),
+                   point.z() + k*m.get_m31());
+        SPoint3 p2(point.x() - k*m.get_m11(),
+                   point.y() - k*m.get_m21(),
+                   point.z() - k*m.get_m31());
+        SPoint3 p3(point.x() + k*m.get_m12(),
+                   point.y() + k*m.get_m22(),
+                   point.z() + k*m.get_m32());
+        SPoint3 p4(point.x() - k*m.get_m12(),
+                   point.y() - k*m.get_m22(),
+                   point.z() - k*m.get_m32());
+        SPoint3 p5(point.x() + k*m.get_m13(),
+                   point.y() + k*m.get_m23(),
+                   point.z() + k*m.get_m33());
+        SPoint3 p6(point.x() - k*m.get_m13(),
+                   point.y() - k*m.get_m23(),
+                   point.z() - k*m.get_m33());
 
         print_segment(point,p1,color1,color2,file);
         print_segment(point,p2,color1,color2,file);
@@ -409,20 +398,22 @@ int Frame_field::build_vertex_to_elements(GEntity* gr, bool initialize)
   return vertex_to_elements.size();
 }
 
-void Frame_field::build_listVertices(GEntity* gr, int dim, bool initialize)
+void Frame_field::build_listVertices(GEntity *gr, int dim, bool initialize)
 {
-  std::set<MVertex*> list;
-  for(unsigned int i=0; i<gr->getNumMeshElements(); i++){
-    MElement* pElem = gr->getMeshElement(i);
-    for(int j=0; j<pElem->getNumVertices(); j++){
-      MVertex * pVertex = pElem->getVertex(j);
-      if(pVertex->onWhat()->dim() == dim)
-    list.insert(pVertex);
+  std::set<MVertex *> list;
+  for(GEntity::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+    MElement *pElem = gr->getMeshElement(i);
+    for(MVertex::size_type j = 0; j < pElem->getNumVertices(); j++) {
+      MVertex *pVertex = pElem->getVertex(j);
+      if(pVertex->onWhat()->dim() == dim) list.insert(pVertex);
     }
   }
   if(initialize) listVertices.clear();
-  for(std::set<MVertex*>::const_iterator it=list.begin(); it!=list.end(); it++)
+
+  for(std::set<MVertex *>::const_iterator it = list.begin(); it != list.end();
+      it++) {
     listVertices.push_back(*it);
+  }
 }
 
 int Frame_field::buildAnnData(GEntity* ge, int dim)
@@ -693,8 +684,8 @@ void Frame_field::buildSmoothness()
     GEntity* eTmp = entities[i];
     for (unsigned int j = 0; j < eTmp->getNumMeshElements();j++){
       MElement* elem = eTmp->getMeshElement(j);
-      for (int k = 0;k < elem->getNumVertices();k++){
-        for (int l = k;l < elem->getNumVertices();l++){
+      for (MElement::size_type k = 0;k < elem->getNumVertices();k++){
+        for (MElement::size_type l = k;l < elem->getNumVertices();l++){
           if (k != l){
             MVertex* v1 = elem->getVertex(k);
             MVertex* v2 = elem->getVertex(l);
@@ -1094,13 +1085,13 @@ void Frame_field::save_energy(GRegion* gr, const std::string& filename)
                       pElem->getVertex(3));
     //std::vector<double> *out = data->incrementList(1, TYPE_TET, NumNodes);
     std::vector<double> *out = data->incrementList(3, TYPE_TET, NumNodes);
-    for(int j = 0; j < pTet->getNumVertices(); j++)
+    for(MTetrahedron::size_type j = 0; j < pTet->getNumVertices(); j++)
       out->push_back(pTet->getVertex(j)->x());
-    for(int j = 0; j < pTet->getNumVertices(); j++)
+    for(MTetrahedron::size_type j = 0; j < pTet->getNumVertices(); j++)
       out->push_back(pTet->getVertex(j)->y());
-    for(int j = 0; j < pTet->getNumVertices(); j++)
+    for(MTetrahedron::size_type j = 0; j < pTet->getNumVertices(); j++)
       out->push_back(pTet->getVertex(j)->z());
-    for(int j = 0; j < pTet->getNumVertices(); j++){
+    for(MTetrahedron::size_type j = 0; j < pTet->getNumVertices(); j++){
       double u, v, w;
       pTet->getNode(j,u,v,w);
       double sf[4], gsf[4][3];
@@ -1141,31 +1132,21 @@ Size_field::Size_field(){}
 void Size_field::init_region(GRegion* gr)
 {
 #if defined(HAVE_ANN)
-  unsigned int i;
-  int j;
-  int index;
-  double h;
-  double e;
-  SPoint3 point;
-  MElement* element;
-  MVertex* vertex;
-  GFace* gf;
+
   GModel* model = GModel::current();
-  ANNpoint query;
-  ANNidxArray indices;
-  ANNdistArray distances;
 
   std::vector<GFace*> faces = gr->faces();
-  std::vector<GFace*>::iterator it;
 
   field.clear();
+  field.reserve(faces.size());
 
+  std::vector<GFace*>::iterator it;
   for(it=faces.begin();it!=faces.end();it++){
-    gf = *it;
+    GFace* gf = *it;
 
-    for(i=0;i<gf->storage1.size();i++){
-      point = gf->storage1[i];
-      h = gf->storage4[i];
+    for(GRegion::size_type i=0;i<gf->storage1.size();i++){
+      SPoint3 point = gf->storage1[i];
+      double const h = gf->storage4[i];
 
       field.push_back(std::pair<SPoint3,double>(point,h));
     }
@@ -1173,7 +1154,7 @@ void Size_field::init_region(GRegion* gr)
 
   ANNpointArray duplicate = annAllocPts(field.size(),3);
 
-  for(i=0;i<field.size();i++){
+  for(GRegion::size_type i=0;i<field.size();i++){
     duplicate[i][0] = field[i].first.x();
     duplicate[i][1] = field[i].first.y();
     duplicate[i][2] = field[i].first.z();
@@ -1183,21 +1164,20 @@ void Size_field::init_region(GRegion* gr)
 
   boundary.clear();
 
-  query = annAllocPt(3);
-  indices = new ANNidx[1];
-  distances = new ANNdist[1];
+  ANNpoint query = annAllocPt(3);
+  ANNidxArray indices = new ANNidx[1];
+  ANNdistArray distances = new ANNdist[1];
 
-  index = 0;
-  e = 0.0;
+  int index = 0;
+  double e = 0.0;
 
   for(it=faces.begin();it!=faces.end();it++){
-    gf = *it;
-
-    for(i=0;i<gf->getNumMeshElements();i++){
-      element = gf->getMeshElement(i);
+    GFace* gf = *it;
 
-      for(j=0;j<element->getNumVertices();j++){
-        vertex = element->getVertex(j);
+    for(GRegion::size_type i=0;i<gf->getNumMeshElements();i++){
+      MElement* element = gf->getMeshElement(i);
+      for(MElement::size_type j=0;j<element->getNumVertices();j++){
+         MVertex* vertex = element->getVertex(j);
 
         query[0] = vertex->x();
         query[1] = vertex->y();
@@ -1699,27 +1679,20 @@ double Nearest_point::clamp(double x,double min,double max)
 
 void Nearest_point::print_field(GRegion* gr)
 {
-  unsigned int i;
-  int j;
-  bool val;
-  double k;
-  double x,y,z;
-  MElement* element;
-  MVertex* vertex;
   SVector3 vec;
 
-  k = 0.05;
+  double const k = 0.05;
   std::ofstream file("nearest.pos");
   file << "View \"test\" {\n";
 
-  for(i=0;i<gr->getNumMeshElements();i++){
-    element = gr->getMeshElement(i);
-    for(j=0;j<element->getNumVertices();j++){
-      vertex = element->getVertex(j);
-      x = vertex->x();
-      y = vertex->y();
-      z = vertex->z();
-      val = search(x,y,z,vec);
+  for(GRegion::size_type i=0;i<gr->getNumMeshElements();i++){
+    MElement* element = gr->getMeshElement(i);
+    for(GRegion::size_type j=0;j<element->getNumVertices();j++){
+      MVertex* vertex = element->getVertex(j);
+      double x = vertex->x();
+      double y = vertex->y();
+      double z = vertex->z();
+      bool const val = search(x,y,z,vec);
       if(val){
         print_segment(SPoint3(x+k*vec.x(),y+k*vec.y(),z+k*vec.z()),
                       SPoint3(x-k*vec.x(),y-k*vec.y(),z-k*vec.z()),file);
diff --git a/Mesh/meshPartition.cpp b/Mesh/meshPartition.cpp
index 8836ae8ac4b7c1698df2f769c710ca2ac1f5506e..f9b3022bbb9cb4b21a34cc0c7d5f13632e625d53 100644
--- a/Mesh/meshPartition.cpp
+++ b/Mesh/meshPartition.cpp
@@ -2366,7 +2366,7 @@ static void assignToParent(std::set<MVertex*> &verts, partitionRegion *region,
       region->getParentEntity()->addElement((*it)->getType(), *it);
     (*it)->setPartition(0);
 
-    for(int i = 0; i < (*it)->getNumVertices(); i++){
+    for(MVertex::size_type i = 0; i < (*it)->getNumVertices(); i++){
       if(verts.find((*it)->getVertex(i)) == verts.end()){
         (*it)->getVertex(i)->setEntity(region->getParentEntity());
         region->getParentEntity()->addMeshVertex((*it)->getVertex(i));
@@ -2385,7 +2385,7 @@ static void assignToParent(std::set<MVertex*> &verts, partitionFace *face,
       face->getParentEntity()->addElement((*it)->getType(), *it);
     (*it)->setPartition(0);
 
-    for(int i = 0; i < (*it)->getNumVertices(); i++){
+    for(MVertex::size_type i = 0; i < (*it)->getNumVertices(); i++){
       if(verts.find((*it)->getVertex(i)) == verts.end()){
         (*it)->getVertex(i)->setEntity(face->getParentEntity());
         face->getParentEntity()->addMeshVertex((*it)->getVertex(i));
@@ -2404,7 +2404,7 @@ static void assignToParent(std::set<MVertex*> &verts, partitionEdge *edge,
       edge->getParentEntity()->addElement((*it)->getType(), *it);
     (*it)->setPartition(0);
 
-    for(int i = 0; i < (*it)->getNumVertices(); i++){
+    for(MVertex::size_type i = 0; i < (*it)->getNumVertices(); i++){
       if(verts.find((*it)->getVertex(i)) == verts.end()){
         (*it)->getVertex(i)->setEntity(edge->getParentEntity());
         edge->getParentEntity()->addMeshVertex((*it)->getVertex(i));
diff --git a/Mesh/meshRefine.cpp b/Mesh/meshRefine.cpp
index eb2ddd5a4d37ca1d778c093639f3a7551b8bdd86..592bddc9f3e8002ce8a42eed56b825d534476441 100644
--- a/Mesh/meshRefine.cpp
+++ b/Mesh/meshRefine.cpp
@@ -79,7 +79,7 @@ static bool setBLData(MElement *el)
     if (!isBL) return false;
   }
   // Mark high-order nodes as BL nodes (only works in 2D)
-  for(int i=el->getNumPrimaryVertices(); i<el->getNumVertices(); i++)
+  for(MVertex::size_type i=el->getNumPrimaryVertices(); i<el->getNumVertices(); i++)
     setBLData(el->getVertex(i));
   return true;
 }
diff --git a/Mesh/simple3D.cpp b/Mesh/simple3D.cpp
index 49e1dc5a0ba7e66b26e629a743b81aa78a97d5e2..7ce467f7af13971c37b6f384358f3c0cd4dd2f3c 100644
--- a/Mesh/simple3D.cpp
+++ b/Mesh/simple3D.cpp
@@ -330,27 +330,19 @@ void Filler::treat_region(GRegion* gr)
     Frame_field::saveCrossField("cross1.pos",scale);
   }
 
-  unsigned int i;
-  int j;
   int count;
   int limit;
   bool ok2;
   double x,y,z;
   SPoint3 point;
   Node *node,*individual,*parent;
-  MVertex* vertex;
-  MElement* element;
+
   MElementOctree* octree;
   deMeshGRegion deleter;
   Wrapper wrapper;
   GFace* gf;
-  std::queue<Node*> fifo;
-  std::vector<Node*> spawns;
   std::vector<Node*> garbage;
   std::vector<MVertex*> boundary_vertices;
-  std::set<MVertex*> temp;
-  std::vector<GFace*> faces;
-  std::map<MVertex*,int> limits;
   std::set<MVertex*>::iterator it;
   std::vector<GFace*>::iterator it2;
   std::map<MVertex*,int>::iterator it3;
@@ -363,19 +355,20 @@ void Filler::treat_region(GRegion* gr)
   octree = new MElementOctree(gr->model());
   garbage.clear();
   boundary_vertices.clear();
-  temp.clear();
   new_vertices.clear();
-  faces.clear();
-  limits.clear();
 
-  faces = gr->faces();
+  std::vector<GFace*> faces = gr->faces();
+  std::map<MVertex*,int> limits;
+
+  std::set<MVertex*> temp;
+
   for(it2=faces.begin();it2!=faces.end();it2++){
     gf = *it2;
     limit = code(gf->tag());
-    for(i=0;i<gf->getNumMeshElements();i++){
-      element = gf->getMeshElement(i);
-      for(j=0;j<element->getNumVertices();j++){
-        vertex = element->getVertex(j);
+    for(GFace::size_type i=0;i<gf->getNumMeshElements();i++){
+      MElement* element = gf->getMeshElement(i);
+      for(MElement::size_type j=0;j<element->getNumVertices();j++){
+        MVertex* vertex = element->getVertex(j);
         temp.insert(vertex);
         limits.insert(std::pair<MVertex*,int>(vertex,limit));
       }
@@ -400,7 +393,9 @@ void Filler::treat_region(GRegion* gr)
     }
   }
 
-  for(i=0;i<boundary_vertices.size();i++){
+  std::queue<Node*> fifo;
+
+  for(MVertex::size_type i=0;i<boundary_vertices.size();i++){
     x = boundary_vertices[i]->x();
     y = boundary_vertices[i]->y();
     z = boundary_vertices[i]->z();
@@ -426,16 +421,14 @@ void Filler::treat_region(GRegion* gr)
       continue;
     }
 
-    spawns.clear();
-    spawns.resize(6);
-
-    for(i=0;i<6;i++){
+    std::vector<Node*> spawns(6);
+    for(int i=0;i<6;i++){
       spawns[i] = new Node();
     }
 
     create_spawns(gr,octree,parent,spawns);
 
-    for(i=0;i<6;i++){
+    for(int i=0;i<6;i++){
       ok2 = 0;
       individual = spawns[i];
       point = individual->get_point();
@@ -457,8 +450,7 @@ void Filler::treat_region(GRegion* gr)
 	  if(wrapper.get_ok()){
 	    fifo.push(individual);
 	    rtree.Insert(individual->min,individual->max,individual);
-	    vertex = new MVertex(x,y,z,gr,0);
-	    new_vertices.push_back(vertex);
+	    new_vertices.push_back(new MVertex(x,y,z,gr,0));
 	    ok2 = 1;
 	    //print_segment(individual->get_point(),parent->get_point(),file);
 	  }
@@ -488,9 +480,9 @@ void Filler::treat_region(GRegion* gr)
 
   CTX::instance()->mesh.algo3d = option;
 
-  for(i=0;i<garbage.size();i++) delete garbage[i];
-  for(i=0;i<new_vertices.size();i++) delete new_vertices[i];
-  new_vertices.clear();
+  for(MVertex::size_type i=0;i<garbage.size();i++) delete garbage[i];
+  for(MVertex::size_type i=0;i<new_vertices.size();i++) delete new_vertices[i];
+
   delete octree;
   rtree.RemoveAll();
   Size_field::clear();
diff --git a/Mesh/surfaceFiller.cpp b/Mesh/surfaceFiller.cpp
index 1697072a807c9f61529100ca3d10e97ef4df8647..cac0271a73a35e13e31d464859c0c603b3e72782 100644
--- a/Mesh/surfaceFiller.cpp
+++ b/Mesh/surfaceFiller.cpp
@@ -52,10 +52,10 @@ bool compute4neighbors (GFace *gf,   // the surface
 			SMetric3 &metricField, FILE *crossf = 0) // the mesh metric
 {
   // we assume that v is on surface gf
-  
+
   // get the parameter of the point on the surface
   reparamMeshVertexOnFace(v_center, gf, midpoint);
-  
+
   double L = backgroundMesh::current()->operator()(midpoint[0],midpoint[1],0.0);
   //  printf("L = %12.5E\n",L);
   metricField = SMetric3(1./(L*L));
@@ -178,7 +178,7 @@ bool compute4neighbors (GFace *gf,   // the surface
 		       (pp.z() - v_center->z())*(pp.z() - v_center->z()) );
       ERR[i] = 100*fabs(D-L)/(D+L);
     }
-    
+
     if (1 && goNonLinear){
       surfaceFunctorGFace ss (gf);                                        //
       SVector3 dirs[4] = {t1*(-1.0),t2*(-1.0),t1*(1.0),t2*(1.0)};                     //
@@ -241,7 +241,9 @@ double get_smoothness(MVertex *v, GFace *gf, const map<MVertex*,double> &vertice
 
   // recover element's vertices:
   vector<MVertex*> localvertices;
-  for (int ivert=0;ivert<elem->getNumVertices();ivert++){
+  localvertices.reserve(elem->getNumVertices());
+
+  for (MVertex::size_type ivert=0;ivert<elem->getNumVertices();ivert++){
     MVertex *temp = elem->getVertex(ivert);
     localvertices.push_back(temp);
 //    cout << " made of vertex " << temp->x() << "," << temp->y() << "," << temp->z() << endl;
@@ -501,9 +503,9 @@ void packingOfParallelogramsSmoothness(GFace* gf,  std::vector<MVertex*> &packed
   multimap<MVertex*,MVertex*> vertex2vertex;
   for (std::vector<MElement*>::iterator it = backgroundMesh::current()->begin_triangles();it!=backgroundMesh::current()->end_triangles();it++){
     MElement *e = *it;
-    for (int i=0;i<e->getNumVertices();i++){
+    for (MElement::size_type i=0;i<e->getNumVertices();i++){
       MVertex *current = e->getVertex(i);
-      for (int j=0;j<e->getNumVertices();j++){
+      for (MVertex::size_type j=0;j<e->getNumVertices();j++){
         if (i==j) continue;
         MVertex *neighbor = e->getVertex(j);
         vertex2vertex.insert(make_pair(current,neighbor));
@@ -591,7 +593,7 @@ void packingOfParallelogramsSmoothness(GFace* gf,  std::vector<MVertex*> &packed
   std::set<MVertex*> bnd_vertices;
   for(unsigned int i=0;i<gf->getNumMeshElements();i++){
     MElement* element = gf->getMeshElement(i);
-    for(int j=0;j<element->getNumVertices();j++){
+    for(MElement::size_type j=0;j<element->getNumVertices();j++){
       MVertex *vertex = element->getVertex(j);
       if (vertex->onWhat()->dim() < 2)bnd_vertices.insert(vertex);
     }
@@ -736,7 +738,7 @@ void packingOfParallelograms(GFace* gf,  std::vector<MVertex*> &packed, std::vec
   std::set<MVertex*> bnd_vertices;
   for(unsigned int i=0;i<gf->getNumMeshElements();i++){
     MElement* element = gf->getMeshElement(i);
-    for(int j=0;j<element->getNumVertices();j++){
+    for(MElement::size_type j=0;j<element->getNumVertices();j++){
       MVertex *vertex = element->getVertex(j);
       if (vertex->onWhat()->dim() < 2)bnd_vertices.insert(vertex);
     }
@@ -772,7 +774,7 @@ void packingOfParallelograms(GFace* gf,  std::vector<MVertex*> &packed, std::vec
 
   //  printf("initially : %d vertices in the domain\n",vertices.size());
 
-  
+
   while(!fifo.empty()){
     surfacePointWithExclusionRegion * parent = *fifo.begin();
     fifo.erase(fifo.begin());
diff --git a/Mesh/yamakawa.cpp b/Mesh/yamakawa.cpp
index 491f255b19805fd90cf424e043e7b2447ac3d523..afc400021069e50a9d3dd102ec443823b9c4199e 100644
--- a/Mesh/yamakawa.cpp
+++ b/Mesh/yamakawa.cpp
@@ -492,28 +492,28 @@ void export_gregion_mesh(GRegion *gr, string filename)
 
   for (vector<MTetrahedron*>::iterator it = gr->tetrahedra.begin();
     it != gr->tetrahedra.end(); it++) {
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MTetrahedron::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       vertices.insert(make_pair((*it)->getVertex(i), counterv));
       counterv++;
     }
   }
   for (vector<MHexahedron*>::iterator it = gr->hexahedra.begin();
     it != gr->hexahedra.end(); it++) {
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MHexahedron::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       vertices.insert(make_pair((*it)->getVertex(i), counterv));
       counterv++;
     }
   }
   for (vector<MPrism*>::iterator it = gr->prisms.begin();
     it != gr->prisms.end(); it++) {
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MPrism::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       vertices.insert(make_pair((*it)->getVertex(i), counterv));
       counterv++;
     }
   }
   for (vector<MPyramid*>::iterator it = gr->pyramids.begin();
     it != gr->pyramids.end(); it++) {
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MPyramid::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       vertices.insert(make_pair((*it)->getVertex(i), counterv));
       counterv++;
     }
@@ -537,7 +537,7 @@ void export_gregion_mesh(GRegion *gr, string filename)
   for (vector<MTetrahedron*>::iterator it = gr->tetrahedra.begin();
     it != gr->tetrahedra.end(); it++) {
     out << counter << " 4 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MTetrahedron::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
     }
@@ -547,7 +547,7 @@ void export_gregion_mesh(GRegion *gr, string filename)
   for (vector<MHexahedron*>::iterator it = gr->hexahedra.begin();
     it != gr->hexahedra.end(); it++) {
     out << counter << " 5 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MHexahedron::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
     }
@@ -557,7 +557,7 @@ void export_gregion_mesh(GRegion *gr, string filename)
   for (vector<MPrism*>::iterator it = gr->prisms.begin();
     it != gr->prisms.end(); it++) {
     out << counter << " 6 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MPrism::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
     }
@@ -567,7 +567,7 @@ void export_gregion_mesh(GRegion *gr, string filename)
   for (vector<MPyramid*>::iterator it = gr->pyramids.begin();
     it != gr->pyramids.end(); it++) {
     out << counter << " 7 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MPyramid::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
     }
@@ -2708,25 +2708,20 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
 }
 
 void Supplementary::build_vertex_to_vertices(GRegion* gr) {
-  size_t i;
-  int j;
-  MElement* element;
-  MVertex *a, *b, *c, *d;
-  std::set<MVertex*> bin;
-  Vertex2Vertices::iterator it;
 
+  std::set<MVertex*> bin;
   vertex_to_vertices.clear();
 
-  for (i = 0; i < gr->getNumMeshElements(); i++) {
-    element = gr->getMeshElement(i);
+  for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+    MElement* element = gr->getMeshElement(i);
     if (four(element)) {
-      for (j = 0; j < element->getNumVertices(); j++) {
-        a = element->getVertex(j);
-        b = element->getVertex((j + 1) % 4);
-        c = element->getVertex((j + 2) % 4);
-        d = element->getVertex((j + 3) % 4);
+      for (MElement::size_type j = 0; j < element->getNumVertices(); j++) {
+        MVertex *a = element->getVertex(j);
+        MVertex *b = element->getVertex((j + 1) % 4);
+        MVertex *c = element->getVertex((j + 2) % 4);
+        MVertex *d = element->getVertex((j + 3) % 4);
 
-        it = vertex_to_vertices.find(a);
+        Vertex2Vertices::iterator it = vertex_to_vertices.find(a);
         if (it != vertex_to_vertices.end()) {
           it->second.insert(b);
           it->second.insert(c);
@@ -2745,22 +2740,17 @@ void Supplementary::build_vertex_to_vertices(GRegion* gr) {
 }
 
 void Supplementary::build_vertex_to_tetrahedra(GRegion* gr) {
-  unsigned int i;
-  int j;
-  MElement* element;
-  MVertex* getVertex;
-  std::set<MElement*> bin;
-  Vertex2Elements::iterator it;
 
+  std::set<MElement*> bin;
   vertex_to_tetrahedra.clear();
 
-  for (i = 0; i < gr->getNumMeshElements(); i++) {
-    element = gr->getMeshElement(i);
+  for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+    MElement* element = gr->getMeshElement(i);
     if (four(element)) {
-      for (j = 0; j < element->getNumVertices(); j++) {
-        getVertex = element->getVertex(j);
+      for (MElement::size_type j = 0; j < element->getNumVertices(); j++) {
+        MVertex* getVertex = element->getVertex(j);
 
-        it = vertex_to_tetrahedra.find(getVertex);
+        Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
         if (it != vertex_to_tetrahedra.end()) {
           it->second.insert(element);
         }
@@ -3135,8 +3125,8 @@ void PostOp::removeElseAdd(std::set<Facet> &set, MVertex *a, MVertex *b, MVertex
 void PostOp::writeMSH(const char *filename, std::vector<MElement*> &elements)
 {
   std::set<MVertex*> vertices;
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    for (int k = 0; k < elements[i]->getNumVertices(); ++k)
+  for (MElement::size_type i = 0; i < elements.size(); ++i) {
+    for (MElement::size_type k = 0; k < elements[i]->getNumVertices(); ++k)
       vertices.insert(elements[i]->getVertex(k));
   }
 
@@ -3158,9 +3148,9 @@ void PostOp::writeMSH(const char *filename, std::vector<MElement*> &elements)
 
   fprintf(f, "$Elements\n");
   fprintf(f, "%d\n", (int)elements.size());
-  for (unsigned int i = 0; i < elements.size(); ++i) {
+  for (MElement::size_type i = 0; i < elements.size(); ++i) {
     fprintf(f, "%d %d 0", elements[i]->getNum(), elements[i]->getTypeForMSH());
-    for (int k = 0; k < elements[i]->getNumVertices(); ++k)
+    for (MElement::size_type k = 0; k < elements[i]->getNumVertices(); ++k)
       fprintf(f, " %d", elements[i]->getVertex(k)->getIndex());
     fprintf(f, "\n");
   }
@@ -4414,7 +4404,7 @@ void PostOp::statistics(GRegion* gr) {
   printf("  percentage of prisms : %.2f\n", vol6*100.0 / vol);
   printf("  percentage of pyramids : %.2f\n", vol5*100.0 / vol);
   printf("  percentage of tetrahedra : %.2f\n", vol4*100.0 / vol);
-  printf("Total number of elements : %d\n", gr->getNumMeshElements());
+  printf("Total number of elements : %lu\n", gr->getNumMeshElements());
   printf("Total volume : %f\n", vol);
   printf("Misc : %d %d %d\n", estimate1, estimate2, iterations);
 }
@@ -4676,14 +4666,11 @@ bool PostOp::different(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4) {
 }
 
 MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2) {
-  int i;
-  MVertex* getVertex;
-  MVertex* pointer;
 
-  pointer = 0;
+  MVertex* pointer = NULL;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
     if (getVertex != v1 && getVertex != v2) {
       pointer = getVertex;
       break;
@@ -4694,14 +4681,11 @@ MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2) {
 }
 
 MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2, MVertex* v3) {
-  int i;
-  MVertex* getVertex;
-  MVertex* pointer;
 
-  pointer = 0;
+  MVertex* pointer = NULL;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
     if (getVertex != v1 && getVertex != v2 && getVertex != v3) {
       pointer = getVertex;
       break;
@@ -4825,14 +4809,11 @@ MVertex* PostOp::findInTriFace(MVertex* in0, MVertex* in1, MVertex* out0, MVerte
 }
 
 MVertex* PostOp::find(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4, MElement* element) {
-  int i;
-  MVertex* getVertex;
-  MVertex* pointer;
 
-  pointer = 0;
+  MVertex* pointer = NULL;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MVertex::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
     if (getVertex != v1 && getVertex != v2 && getVertex != v3 && getVertex != v4) {
       pointer = getVertex;
       break;
@@ -5037,15 +5018,13 @@ void PostOp::build_vertex_to_tetrahedra(GRegion* gr) {
 }
 
 void PostOp::build_vertex_to_tetrahedra(MElement* element) {
-  int i;
-  MVertex* getVertex;
+
   std::set<MElement*> bin;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_tetrahedra.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
     if (it != vertex_to_tetrahedra.end()) {
       it->second.insert(element);
     }
@@ -5058,14 +5037,11 @@ void PostOp::build_vertex_to_tetrahedra(MElement* element) {
 }
 
 void PostOp::erase_vertex_to_tetrahedra(MElement* element) {
-  int i;
-  MVertex* getVertex;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_tetrahedra.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
     if (it != vertex_to_tetrahedra.end()) {
       it->second.erase(element);
     }
@@ -5073,13 +5049,11 @@ void PostOp::erase_vertex_to_tetrahedra(MElement* element) {
 }
 
 void PostOp::build_vertex_to_pyramids(GRegion* gr) {
-  unsigned int i;
-  MElement* element;
 
   vertex_to_pyramids.clear();
 
-  for (i = 0; i < gr->getNumMeshElements(); i++) {
-    element = gr->getMeshElement(i);
+  for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+    MElement* element = gr->getMeshElement(i);
     if (five(element)) {
       build_vertex_to_pyramids(element);
     }
@@ -5087,15 +5061,13 @@ void PostOp::build_vertex_to_pyramids(GRegion* gr) {
 }
 
 void PostOp::build_vertex_to_pyramids(MElement* element) {
-  int i;
-  MVertex* getVertex;
+
   std::set<MElement*> bin;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_pyramids.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_pyramids.find(getVertex);
     if (it != vertex_to_pyramids.end()) {
       it->second.insert(element);
     }
@@ -5108,14 +5080,11 @@ void PostOp::build_vertex_to_pyramids(MElement* element) {
 }
 
 void PostOp::erase_vertex_to_pyramids(MElement* element) {
-  int i;
-  MVertex* getVertex;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_pyramids.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_pyramids.find(getVertex);
     if (it != vertex_to_pyramids.end()) {
       it->second.erase(element);
     }
@@ -5124,13 +5093,11 @@ void PostOp::erase_vertex_to_pyramids(MElement* element) {
 
 
 void PostOp::build_vertex_to_hexPrism(GRegion* gr) {
-  unsigned int i;
-  MElement* element;
 
   vertex_to_hexPrism.clear();
 
-  for (i = 0; i < gr->getNumMeshElements(); i++) {
-    element = gr->getMeshElement(i);
+  for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+    MElement* element = gr->getMeshElement(i);
     if (six(element) || eight(element)) {
       build_vertex_to_hexPrism(element);
     }
@@ -5138,15 +5105,13 @@ void PostOp::build_vertex_to_hexPrism(GRegion* gr) {
 }
 
 void PostOp::build_vertex_to_hexPrism(MElement* element) {
-  int i;
-  MVertex* getVertex;
+
   std::set<MElement*> bin;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_hexPrism.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_hexPrism.find(getVertex);
     if (it != vertex_to_hexPrism.end()) {
       it->second.insert(element);
     }
@@ -5159,14 +5124,11 @@ void PostOp::build_vertex_to_hexPrism(MElement* element) {
 }
 
 void PostOp::erase_vertex_to_hexPrism(MElement* element) {
-  int i;
-  MVertex* getVertex;
-  Vertex2Elements::iterator it;
 
-  for (i = 0; i < element->getNumVertices(); i++) {
-    getVertex = element->getVertex(i);
+  for (MElement::size_type i = 0; i < element->getNumVertices(); i++) {
+    MVertex* getVertex = element->getVertex(i);
 
-    it = vertex_to_hexPrism.find(getVertex);
+    Vertex2Elements::iterator it = vertex_to_hexPrism.find(getVertex);
     if (it != vertex_to_hexPrism.end()) {
       it->second.erase(element);
     }
@@ -5191,9 +5153,9 @@ bool PostOp::valid(MPyramid *pyr) {
         SVector3 vec2 = SVector3(V[(1 + iP) % 4]->x() - apex->x(), V[(1 + iP) % 4]->y() - apex->y(), V[(1 + iP) % 4]->z() - apex->z()).unit();
         SVector3 vec3 = SVector3(V[(2 + iP) % 4]->x() - apex->x(), V[(2 + iP) % 4]->y() - apex->y(), V[(2 + iP) % 4]->z() - apex->z()).unit();
         SVector3 crossVec1Vec2 = crossprod(vec1, vec2);
-        double angle = fabs(acos(dot(crossVec1Vec2, vec3)) * 180 / M_PI);
+        double angle = std::abs(std::acos(dot(crossVec1Vec2, vec3)) * 180 / M_PI);
         double minAngle = 30;
-        if (fabs(angle - 90) < minAngle) return false;
+        if (std::abs(angle - 90) < minAngle) return false;
       }
     }
   }
@@ -5365,7 +5327,7 @@ void clique_stop_criteria<T>::export_corresponding_mesh
   int countertets = 1;
   for (set<MElement*>::iterator it = hexs.begin(); it != hexs.end(); it++) {
     out << counter << " 5 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MElement::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
     }
@@ -5376,7 +5338,7 @@ void clique_stop_criteria<T>::export_corresponding_mesh
   for (set<MElement*>::iterator it = tets.begin(); it != tets.end(); it++) {
     out << counter << " 4 2 0 26";
     outtets << counter << " 4 2 0 26";
-    for (int i = 0; i < (*it)->getNumVertices(); i++) {
+    for (MElement::size_type i = 0; i < (*it)->getNumVertices(); i++) {
       MVertex *v = (*it)->getVertex(i);
       out << " " << vertices[v];
       outtets << " " << vertices[v];
diff --git a/Plugin/Crack.cpp b/Plugin/Crack.cpp
index ba16c8f1c51f894ec7ba066ced2063a6c54c0b40..0aabeed2ab8d32788dda6b0aed4a4c5579f2d66a 100644
--- a/Plugin/Crack.cpp
+++ b/Plugin/Crack.cpp
@@ -125,7 +125,7 @@ PView *GMSH_CrackPlugin::execute(PView *view)
   std::set<MVertex*> crackVertices, bndVertices;
   if(dim == 1){
     for(unsigned int i = 0; i < crackElements.size(); i++){
-      for(int j = 0; j < crackElements[i]->getNumVertices(); j++){
+      for(MVertex::size_type j = 0; j < crackElements[i]->getNumVertices(); j++){
         MVertex *v = crackElements[i]->getVertex(j);
         crackVertices.insert(v);
       }
@@ -141,7 +141,7 @@ PView *GMSH_CrackPlugin::execute(PView *view)
   else{
     std::set<EdgeData, Less_EdgeData> bnd;
     for(unsigned int i = 0; i < crackElements.size(); i++){
-      for(int j = 0; j < crackElements[i]->getNumVertices(); j++){
+      for(MVertex::size_type j = 0; j < crackElements[i]->getNumVertices(); j++){
         MVertex *v = crackElements[i]->getVertex(j);
         crackVertices.insert(v);
       }
@@ -163,7 +163,7 @@ PView *GMSH_CrackPlugin::execute(PView *view)
   for(unsigned int i = 0; i < openEntities.size(); i++){
     for(unsigned int j = 0; j < openEntities[i]->getNumMeshElements(); j++){
       MElement *e = openEntities[i]->getMeshElement(j);
-      for(int k = 0; k < e->getNumVertices(); k++){
+      for(MElement::size_type k = 0; k < e->getNumVertices(); k++){
         MVertex *v = e->getVertex(k);
         bndVertices.erase(v);
       }
@@ -181,7 +181,7 @@ PView *GMSH_CrackPlugin::execute(PView *view)
     if(crackEntities.find(allentities[ent]) != crackEntities.end()) continue;
     for(unsigned int i = 0; i < allentities[ent]->getNumMeshElements(); i++){
       MElement *e = allentities[ent]->getMeshElement(i);
-      for(int j = 0; j < e->getNumVertices(); j++){
+      for(MElement::size_type j = 0; j < e->getNumVertices(); j++){
         if(crackVertices.find(e->getVertex(j)) != crackVertices.end()){
           // element touches the crack: find the closest crack element
           SPoint3 b = e->barycenter();
@@ -265,7 +265,7 @@ PView *GMSH_CrackPlugin::execute(PView *view)
   // replace vertices in elements on one side of the crack
   for(std::set<MElement*>::iterator it = oneside.begin(); it != oneside.end(); it++){
     MElement *e = *it;
-    for(int i = 0; i < e->getNumVertices(); i++){
+    for(MElement::size_type i = 0; i < e->getNumVertices(); i++){
       if(vxv.count(e->getVertex(i)))
         e->setVertex(i, vxv[e->getVertex(i)]);
     }
diff --git a/Plugin/Distance.cpp b/Plugin/Distance.cpp
index 4aa63ff112550d597db5633d06bc84b1d4339a47..aee2207a7f461082ba1afad008dd903e6ff1ef83 100644
--- a/Plugin/Distance.cpp
+++ b/Plugin/Distance.cpp
@@ -136,7 +136,7 @@ void GMSH_DistancePlugin::printView(std::vector<GEntity*> _entities,
             nods.push_back(e->getVertex(i));
         else
           for(int i = 0; i < e->getNumChildren(); i++)
-            for(int j = 0; j < e->getChild(i)->getNumVertices(); j++)
+            for(MVertex::size_type j = 0; j < e->getChild(i)->getNumVertices(); j++)
               nods.push_back(e->getChild(i)->getVertex(j));
 
         for (int nod = 0; nod < numNodes; nod++) out->push_back((nods[nod])->x());
@@ -372,7 +372,7 @@ PView *GMSH_DistancePlugin::execute(PView *v)
         existEntity = true;
         for (unsigned int i = 0; i < ge->getNumMeshElements(); ++i) {
           MElement *t = ge->getMeshElement(i);
-          for (int k=0; k<t->getNumVertices(); k++) {
+          for (MElement::size_type k=0; k<t->getNumVertices(); k++) {
             MVertex *v = t->getVertex(k);
             dofView->fixVertex(v, 0, 1, 0.);
             bbox += SPoint3(v->x(), v->y(), v->z());
@@ -394,7 +394,7 @@ PView *GMSH_DistancePlugin::execute(PView *v)
           for(unsigned int i = 0; i < ge->getNumMeshElements(); ++i) {
             MElement *t = ge->getMeshElement(i);
             allElems.push_back(t);
-            for (int k = 0; k < t->getNumVertices(); k++)
+            for (MElement::size_type k = 0; k < t->getNumVertices(); k++)
               dofView->numberVertex(t->getVertex(k), 0, 1);
           }
         }
@@ -460,7 +460,7 @@ PView *GMSH_DistancePlugin::execute(PView *v)
         for (unsigned int i=0; i<ge->getNumMeshElements(); ++i) {
           MElement *t = ge->getMeshElement(i);
           double vMean = 0.0;
-          for (int k = 0; k < t->getNumVertices(); k++) {
+          for (MElement::size_type k = 0; k < t->getNumVertices(); k++) {
             std::map<MVertex*, double>::iterator it = _distance_map.find(t->getVertex(k));
             vMean += it->second;
           }
@@ -479,7 +479,7 @@ PView *GMSH_DistancePlugin::execute(PView *v)
     for (std::vector<MElement* >::iterator it = allElems.begin();
          it != allElems.end(); it++){
       MElement *t = *it;
-      for(int k = 0; k < t->getNumVertices(); k++)
+      for(MElement::size_type k = 0; k < t->getNumVertices(); k++)
         myAssembler.numberVertex(t->getVertex(k), 0, 1);
     }
 
@@ -535,7 +535,7 @@ PView *GMSH_DistancePlugin::execute(PView *v)
         nods.push_back(e->getVertex(i));
     else
       for(int i = 0; i < e->getNumChildren(); i++)
-        for(int j = 0; j < e->getChild(i)->getNumVertices(); j++)
+        for(MElement::size_type j = 0; j < e->getChild(i)->getNumVertices(); j++)
           nods.push_back(e->getChild(i)->getVertex(j));
 
     for(int nod = 0; nod < numNodes; nod++) out2->push_back((nods[nod])->x());
diff --git a/Plugin/FaultZone.cpp b/Plugin/FaultZone.cpp
index 390846af380503100d2b63b95869adc1ac7f1515..265193e01c4955e448c109e98445a3d09e6b4a90 100644
--- a/Plugin/FaultZone.cpp
+++ b/Plugin/FaultZone.cpp
@@ -199,7 +199,7 @@ void GMSH_FaultZoneMesher::RetriveFissuresInfos(GFace* gFace){
   // fill _connectedElements
   for(unsigned int i = 0; i < gFace->getNumMeshElements(); i++){
     MElement *mElem = gFace->getMeshElement(i);
-    for (int j = 0; j < mElem->getNumVertices(); j++){
+    for (MElement::size_type j = 0; j < mElem->getNumVertices(); j++){
       MVertex *mVert = mElem->getVertex(j);
       std::set < MVertex* >::iterator its = allFissuresVertices.find( mVert );
       if (its != allFissuresVertices.end()){
@@ -214,7 +214,7 @@ void GMSH_FaultZoneMesher::RetriveFissuresInfos(GFace* gFace){
     GEdge *gEdge = *itl;
     for(unsigned int i = 0; i < gEdge->getNumMeshElements(); i++){
       MElement *mElem = gEdge->getMeshElement(i);
-      for (int j = 0; j < mElem->getNumVertices(); j++){
+      for (MElement::size_type j = 0; j < mElem->getNumVertices(); j++){
         MVertex *mVert = mElem->getVertex(j);
         std::set < MVertex* >::iterator its = allFissuresVertices.find( mVert );
         if (its != allFissuresVertices.end()){
@@ -273,7 +273,7 @@ void GMSH_FaultZoneMesher::RetriveFissuresInfos(GFace* gFace){
       }
 
       _jointElements.insert(mElem);
-      for(int j = 0; j < mElem->getNumVertices(); j++){
+      for(MVertex::size_type j = 0; j < mElem->getNumVertices(); j++){
         MVertex *mVert = mElem->getVertex(j);
         _fissureByHeavNode[mVert] = gEdge;
       }
@@ -576,7 +576,7 @@ void GMSH_FaultZoneMesher::CreateJointElements(GModel* gModel, GFace* gFace,
                      "outgoing normal for its corresponding joint element",
                      mElem->getNum());
       // retriving MVertices to create the new MElement
-      for(int i = 0; i < mElem->getNumVertices(); i++){
+      for(MVertex::size_type i = 0; i < mElem->getNumVertices(); i++){
         MVertex *mVert = mElem->getVertex(i);
 
         int j = (changeOri && i < 2) ? !i : i;
diff --git a/Plugin/FieldFromAmplitudePhase.cpp b/Plugin/FieldFromAmplitudePhase.cpp
index 5e7f2575a24b59060f03d7aa60e62be13dcaa98f..51bb826e8339b2948e64581b6e794dd7c5b24289 100644
--- a/Plugin/FieldFromAmplitudePhase.cpp
+++ b/Plugin/FieldFromAmplitudePhase.cpp
@@ -114,7 +114,7 @@ PView *GMSH_FieldFromAmplitudePhasePlugin::execute(PView *v)
   for(unsigned int ent = 0; ent < _entities.size(); ent++)
     for(unsigned int ele = 0; ele < _entities[ent]->getNumMeshElements(); ele++){
       MElement *e = _entities[ent]->getMeshElement(ele);
-      for(int nod = 0; nod < e->getNumVertices() ; nod++)
+      for(MElement::size_type nod = 0; nod < e->getNumVertices() ; nod++)
         ve.insert(e->getVertex(nod));
     }
 
diff --git a/Plugin/ShowNeighborElements.cpp b/Plugin/ShowNeighborElements.cpp
index 15956f723f0e79b1285745f7d1f311f1316f607a..b962732e19aaa175493d1d2f6faa3e36d652c8b4 100644
--- a/Plugin/ShowNeighborElements.cpp
+++ b/Plugin/ShowNeighborElements.cpp
@@ -86,13 +86,13 @@ void GMSH_ShowNeighborElementsPlugin::_init(GEntity *ent)
         el->getNum() == _nel4 ||
         el->getNum() == _nel5) {
       el->setVisibility(true);
-      for (int k = 0; k < el->getNumVertices(); ++k) { // TODO only corner vertices?
+      for (MElement::size_type k = 0; k < el->getNumVertices(); ++k) { // TODO only corner vertices?
         _vertices.insert(el->getVertex(k));
       }
     }
     else {
       el->setVisibility(false);
-      for (int k = 0; k < el->getNumVertices(); ++k) { // TODO only corner vertices?
+      for (MElement::size_type k = 0; k < el->getNumVertices(); ++k) { // TODO only corner vertices?
         _vert2elem.insert(std::make_pair(el->getVertex(k), el));
       }
     }
diff --git a/Plugin/SimplePartition.cpp b/Plugin/SimplePartition.cpp
index 5d70c02c9af26ba40be24c770da1881961ce6444..a28973d86793f1b24b33263a5a6079a480630727 100644
--- a/Plugin/SimplePartition.cpp
+++ b/Plugin/SimplePartition.cpp
@@ -112,7 +112,7 @@ void GMSH_SimplePartitionPlugin::run()
     for(unsigned int j = 0; j < ge->getNumMeshElements(); j++){
       MElement *e = ge->getMeshElement(j);
       SPoint3 point = e->barycenter();
-      for(unsigned int k = 0; k < numSlices; k++){
+      for(int k = 0; k < numSlices; k++){
         if(pp[k] < point[direction] && pp[k+1] >= point[direction]){
           elmToPartition.insert(std::pair<MElement*, unsigned int>(e, k+1));
           break;
diff --git a/Plugin/ThinLayerFixMesh.cpp b/Plugin/ThinLayerFixMesh.cpp
index c61e3d935641a3c1b16bf824b4ded409e8bb1b58..aae87b0b517f43ed557966b64f60a7ca29d06ce1 100644
--- a/Plugin/ThinLayerFixMesh.cpp
+++ b/Plugin/ThinLayerFixMesh.cpp
@@ -415,7 +415,7 @@ void GMSH_ThinLayerFixMeshPlugin::fillvecOfThinSheets()
                   MVertex* VToDo = (*CurrentSheet.begin());
                   std::vector<MTetrahedron*> surroundingTet = VertexToTets[VToDo];
                   for (unsigned int j = 0;j < surroundingTet.size();j++){
-                    for (int k = 0;k < surroundingTet[j]->getNumVertices();k++){
+                    for (MVertex::size_type k = 0;k < surroundingTet[j]->getNumVertices();k++){
                       MVertex* ToInsertTmp = surroundingTet[j]->getVertex(k);
                       std::map<MVertex*,std::vector<CorrespVerticesFixMesh*> >::iterator it2 = VertexToCorresp.find(ToInsertTmp);
                       if (ToInsertTmp->onWhat()->tag() == VToDo->onWhat()->tag()){//TODO: OR that onwhat -> dim <, for edges
diff --git a/Plugin/VoroMetal.cpp b/Plugin/VoroMetal.cpp
index b53b2c7f0ab0480600399577571b1e37f98f95ef..f848680a0e10707998b7529855507f11314e7213 100644
--- a/Plugin/VoroMetal.cpp
+++ b/Plugin/VoroMetal.cpp
@@ -79,30 +79,24 @@ void voroMetal3D::execute(double h)
 
 void voroMetal3D::execute(GRegion* gr,double h)
 {
-  unsigned int i;
-  int j;
-  MElement* element;
-  MVertex* vertex;
-  std::vector<SPoint3> vertices2;
-  std::vector<double> radii;
   std::set<MVertex*> vertices;
   std::set<MVertex*>::iterator it;
 
-  vertices2.clear();
-  radii.clear();
-  vertices.clear();
-
-  for(i = 0; i < gr->getNumMeshElements(); i++){
-    element = gr->getMeshElement(i);
-    for(j = 0; j < element->getNumVertices(); j++){
-      vertex = element->getVertex(j);
+  for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++){
+    MElement* element = gr->getMeshElement(i);
+    for(MElement::size_type j = 0; j < element->getNumVertices(); j++){
+      MVertex* vertex = element->getVertex(j);
       vertices.insert(vertex);
     }
   }
 
+  std::vector<SPoint3> vertices2;
+  vertices2.reserve(vertices.size());
+
+  std::vector<double> radii(vertices.size(), 1.0);
+
   for(it = vertices.begin(); it != vertices.end(); it++){
     vertices2.push_back(SPoint3((*it)->x(),(*it)->y(),(*it)->z()));
-    radii.push_back(1.0);
   }
 
   double xMax = 1.0;
diff --git a/Post/OctreePost.cpp b/Post/OctreePost.cpp
index a304d2f8c7917cd9bed46368165f7608fdb4be53..7519504c57ca601bc744ec935bbf48106eaa07f4 100644
--- a/Post/OctreePost.cpp
+++ b/Post/OctreePost.cpp
@@ -403,13 +403,13 @@ static MElement *getElement(double P[3], GModel *m,
     double eps = CTX::instance()->geom.tolerance;
     std::vector<MElement*> elements = m->getMeshElementsByCoord(pt);
     for(unsigned int i = 0; i < elements.size(); i++){
-      if(qn == elements[i]->getNumVertices()){
+      if(qn == static_cast<int>(elements[i]->getNumVertices())){
         bool ok = true;
         for(int j = 0; j < qn; j++){
           MVertex *v = elements[i]->getVertex(j);
-          ok &= (fabs(v->x() - qx[j]) < eps &&
-                 fabs(v->y() - qy[j]) < eps &&
-                 fabs(v->z() - qz[j]) < eps);
+          ok &= (std::abs(v->x() - qx[j]) < eps &&
+                 std::abs(v->y() - qy[j]) < eps &&
+                 std::abs(v->z() - qz[j]) < eps);
         }
         if(ok) return elements[i];
       }
@@ -433,7 +433,7 @@ bool OctreePost::_getValue(void *in, int dim, int nbNod, int nbComp,
   //  for (int i=0;i<3*9*3;i++)printf("%g ", X[i]);
   //  printf("\n");
 
-  
+
   elementFactory factory;
   element *e = factory.create(nbNod, dim, X, Y, Z);
   if(!e) return false;
@@ -482,10 +482,10 @@ bool OctreePost::_getValue(void *in, int nbComp, double P[3], int timestep,
 
   std::vector<int> dataIndex(e->getNumVertices());
   if(_theViewDataGModel->getType() == PViewDataGModel::NodeData)
-    for(int i = 0; i < e->getNumVertices(); i++)
+    for(MElement::size_type i = 0; i < e->getNumVertices(); i++)
       dataIndex[i] = e->getVertex(i)->getNum();
   else
-    for(int i = 0; i < e->getNumVertices(); i++)
+    for(MElement::size_type i = 0; i < e->getNumVertices(); i++)
       dataIndex[i] = e->getNum();
 
   double U[3];
@@ -495,7 +495,7 @@ bool OctreePost::_getValue(void *in, int nbComp, double P[3], int timestep,
   for(int step = 0; step < _theViewDataGModel->getNumTimeSteps(); step++){
     if(!_theViewDataGModel->hasTimeStep(step)) continue;
     if(timestep < 0 || step == timestep){
-      for(int nod = 0; nod < e->getNumVertices(); nod++){
+      for(MElement::size_type nod = 0; nod < e->getNumVertices(); nod++){
         for(int comp = 0; comp < nbComp; comp++)
           _theViewDataGModel->getValueByIndex(step, dataIndex[nod], nod, comp,
                                               nodeval[nod * nbComp + comp]);
diff --git a/Post/PViewDataGModel.cpp b/Post/PViewDataGModel.cpp
index 2ffd5a4e080d163b0ec09c7ff939a267f67f90cf..9bd9514a229767a39aa282f5c94967ad0bd195c6 100644
--- a/Post/PViewDataGModel.cpp
+++ b/Post/PViewDataGModel.cpp
@@ -717,7 +717,7 @@ void PViewDataGModel::smooth()
         MElement *e = _steps[step]->getEntity(ent)->getMeshElement(ele);
         double val;
         if(!getValueByIndex(step, e->getNum(), 0, 0, val)) continue;
-        for(int nod = 0; nod < e->getNumVertices(); nod++){
+        for(MElement::size_type nod = 0; nod < e->getNumVertices(); nod++){
           MVertex *v = e->getVertex(nod);
           if(nodeConnect.count(v->getNum()))
             nodeConnect[v->getNum()]++;
diff --git a/Solver/STensor43.cpp b/Solver/STensor43.cpp
index 1c6439ce873444677e10f1a2d3862aceaa407c51..34d29c1ca934f24cd1bba411dc7a9631cb94ca44 100644
--- a/Solver/STensor43.cpp
+++ b/Solver/STensor43.cpp
@@ -13,7 +13,7 @@ void STensor43::print (const char *s) const
 {
   char format[2048];
   const char l[256] = "%12.5E %12.5E %12.5E  %12.5E %12.5E %12.5E  %12.5E %12.5E %12.5E \n";
-  sprintf (format, " tensor4 %s : \n %s %s %s \n %s %s %s \n %s %s %s \n",s, l,l,l, l,l,l, l,l,l);
+  sprintf(format, " tensor4 %s : \n %s %s %s \n %s %s %s \n %s %s %s \n",s, l,l,l, l,l,l, l,l,l);
   printf(format, s,
          _val[ 0],_val[ 1],_val[ 2], _val[ 3],_val[ 4],_val[ 5], _val[ 6],_val[ 7],_val[ 8],
          _val[ 9],_val[10],_val[11], _val[12],_val[13],_val[14], _val[15],_val[16],_val[17],
diff --git a/Solver/elasticitySolver.cpp b/Solver/elasticitySolver.cpp
index cffb81648cffa7af7ddc6b0dd061d457a1055694..2dde74b7ce2798d1a5a904d6cee2d19a0799708c 100644
--- a/Solver/elasticitySolver.cpp
+++ b/Solver/elasticitySolver.cpp
@@ -672,13 +672,13 @@ double elasticitySolver::computeDisplacementError(simpleFunction<double> *f0, si
          it != elasticFields[i].g->end(); ++it){
       MElement *e = *it;
       if(e->getParent()) {
-        for (int j = 0; j < e->getNumVertices(); ++j) {
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j) {
           if(vCut.find(e->getVertex(j)) == vCut.end())
             vCut[e->getVertex(j)] = e->getParent();
         }
       }
       else {
-        for (int j = 0; j < e->getNumVertices(); ++j)
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j)
           v.insert(e->getVertex(j));
       }
     }
@@ -799,13 +799,13 @@ PView* elasticitySolver::buildDisplacementView (const std::string postFileName)
          it != elasticFields[i].g->end(); ++it){
       MElement *e = *it;
       if(e->getParent()) {
-        for (int j = 0; j < e->getNumVertices(); ++j) {
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j) {
           if(vCut.find(e->getVertex(j)) == vCut.end())
             vCut[e->getVertex(j)] = e->getParent();
         }
       }
       else {
-        for (int j = 0; j < e->getNumVertices(); ++j)
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j)
           v.insert(e->getVertex(j));
       }
     }
@@ -978,7 +978,7 @@ PView* elasticitySolver::buildLagrangeMultiplierView (const std::string postFile
           LagrangeMultiplierFields[i].g->begin();
         it != LagrangeMultiplierFields[i].g->end(); ++it){
       MElement *e = *it;
-      for (int j = 0; j < e->getNumVertices(); ++j) v.insert(e->getVertex(j));
+      for (MElement::size_type j = 0; j < e->getNumVertices(); ++j) v.insert(e->getVertex(j));
     }
   }
   std::map<int, std::vector<double> > data;
diff --git a/Solver/filters.h b/Solver/filters.h
index 77752a9a6a6743fd9c99d4f6f77d78b156a66648..44d602486ff900a5fdadcd7128ff7b9de991e1ea 100644
--- a/Solver/filters.h
+++ b/Solver/filters.h
@@ -76,7 +76,7 @@ class FilterElementsCutByLevelSet
     for (; it != LevelSetElements->end(); it++)	{
       MElement *e = *it;
       if (e->getParent()){ // if element got parents
-        for (int k = 0; k < e->getParent()->getNumVertices(); ++k){  // for all vertices in the element parent
+        for (MElement::size_type k = 0; k < e->getParent()->getNumVertices(); ++k){  // for all vertices in the element parent
           _TagEnrichedVertex.insert(e->getParent()->getVertex(k)->getNum());
         }
       }
diff --git a/Solver/thermicSolver.cpp b/Solver/thermicSolver.cpp
index dcc40263a9ba228bb1c2c1ee8bb78514a02006d9..d4226554f069b5e58beba34c6c8f28f918d4dd75 100644
--- a/Solver/thermicSolver.cpp
+++ b/Solver/thermicSolver.cpp
@@ -257,13 +257,13 @@ PView* thermicSolver::buildTemperatureView (const std::string postFileName)
     for (groupOfElements::elementContainer::const_iterator it = thermicFields[i].g->begin(); it != thermicFields[i].g->end(); ++it){
       MElement *e = *it;
       if(e->getParent()) {
-        for (int j = 0; j < e->getNumVertices(); ++j) {
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j) {
           if(vCut.find(e->getVertex(j)) == vCut.end())
             vCut[e->getVertex(j)] = e->getParent();
         }
       }
       else {
-        for (int j = 0; j < e->getNumVertices(); ++j)
+        for (MElement::size_type j = 0; j < e->getNumVertices(); ++j)
           v.insert(e->getVertex(j));
       }
     }
@@ -299,7 +299,7 @@ PView* thermicSolver::buildLagrangeMultiplierView (const std::string postFileNam
     for(groupOfElements::elementContainer::const_iterator it = LagrangeMultiplierFields[i].g->begin();
         it != LagrangeMultiplierFields[i].g->end(); ++it){
       MElement *e = *it;
-      for (int j = 0; j < e->getNumVertices(); ++j) v.insert(e->getVertex(j));
+      for (MElement::size_type j = 0; j < e->getNumVertices(); ++j) v.insert(e->getVertex(j));
     }
   }
   std::map<int, std::vector<double> > data;