diff --git a/Geo/MElement.h b/Geo/MElement.h
index 9cef0e28a73149cd72e68732942615edb0ecd146..8955f835f43f98c0ed89863641fc235cebc8fa0f 100644
--- a/Geo/MElement.h
+++ b/Geo/MElement.h
@@ -238,7 +238,7 @@ class MElement
   virtual void getShapeFunctions(double u, double v, double w, double s[],
                                  int order=-1) const;
 
-  // return the gradient of of the nodal shape functions evaluated at
+  // return the gradient of the nodal shape functions evaluated at
   // point (u,v,w) in parametric coordinates (if order == -1, use the
   // polynomial order of the element)
   virtual void getGradShapeFunctions(double u, double v, double w, double s[][3],
diff --git a/Geo/MHexahedron.cpp b/Geo/MHexahedron.cpp
index 3458b4ce7a39f0d815fb6aabb0ca1c38223fc4fa..413efd772093218822789481bfa862fb4cbd8b62 100644
--- a/Geo/MHexahedron.cpp
+++ b/Geo/MHexahedron.cpp
@@ -194,44 +194,18 @@ const nodalBasis* MHexahedron::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_HEX_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_HEX_8);
-    case 2: return BasisFactory::getNodalBasis(MSH_HEX_27);
-    case 3: return BasisFactory::getNodalBasis(MSH_HEX_64);
-    case 4: return BasisFactory::getNodalBasis(MSH_HEX_125);
-    case 5: return BasisFactory::getNodalBasis(MSH_HEX_216);
-    case 6: return BasisFactory::getNodalBasis(MSH_HEX_343);
-    case 7: return BasisFactory::getNodalBasis(MSH_HEX_512);
-    case 8: return BasisFactory::getNodalBasis(MSH_HEX_729);
-    case 9: return BasisFactory::getNodalBasis(MSH_HEX_1000);
-    default: Msg::Error("Order %d hex function space not implemented", order); break;
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_HEX, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MHexahedron::getJacobianFuncSpace(int order) const
 {
   if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getJacobianBasis(MSH_HEX_1);
-    case 1: return BasisFactory::getJacobianBasis(MSH_HEX_8);
-    case 2: return BasisFactory::getJacobianBasis(MSH_HEX_27);
-    case 3: return BasisFactory::getJacobianBasis(MSH_HEX_64);
-    case 4: return BasisFactory::getJacobianBasis(MSH_HEX_125);
-    case 5: return BasisFactory::getJacobianBasis(MSH_HEX_216);
-    case 6: return BasisFactory::getJacobianBasis(MSH_HEX_343);
-    case 7: return BasisFactory::getJacobianBasis(MSH_HEX_512);
-    case 8: return BasisFactory::getJacobianBasis(MSH_HEX_729);
-    case 9: return BasisFactory::getJacobianBasis(MSH_HEX_1000);
-    default: Msg::Error("Order %d hex Jacobian function space not implemented", order); break;
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_HEX, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
-
-
 void _myGetFaceRep(MHexahedron *hex, int num, double *x, double *y, double *z,
                           SVector3 *n, int numSubEdges)
 {
diff --git a/Geo/MLine.cpp b/Geo/MLine.cpp
index 42766c6031bf19b0520fcfa9d7a0b91d072c1c35..4fd16e3f44a7bf9c0f08c58baac69088dd84cb3a 100644
--- a/Geo/MLine.cpp
+++ b/Geo/MLine.cpp
@@ -11,45 +11,20 @@
 #include "Context.h"
 #include "qualityMeasures.h"
 
-const nodalBasis* MLine::getFunctionSpace(int o) const
+const nodalBasis* MLine::getFunctionSpace(int order) const
 {
-  int order = (o == -1) ? getPolynomialOrder() : o;
-  
-  switch (order) {
-  case 0: return BasisFactory::getNodalBasis(MSH_LIN_1);
-  case 1: return BasisFactory::getNodalBasis(MSH_LIN_2);
-  case 2: return BasisFactory::getNodalBasis(MSH_LIN_3);
-  case 3: return BasisFactory::getNodalBasis(MSH_LIN_4);
-  case 4: return BasisFactory::getNodalBasis(MSH_LIN_5);
-  case 5: return BasisFactory::getNodalBasis(MSH_LIN_6);
-  case 6: return BasisFactory::getNodalBasis(MSH_LIN_7);
-  case 7: return BasisFactory::getNodalBasis(MSH_LIN_8);
-  case 8: return BasisFactory::getNodalBasis(MSH_LIN_9);
-  case 9: return BasisFactory::getNodalBasis(MSH_LIN_10);
-  case 10: return BasisFactory::getNodalBasis(MSH_LIN_11);
-  default: Msg::Error("Order %d line function space not implemented", order);
-  }
-  return 0;
+  if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
+
+  int tag = ElementType::getTag(TYPE_LIN, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
-const JacobianBasis* MLine::getJacobianFuncSpace(int o) const
+const JacobianBasis* MLine::getJacobianFuncSpace(int order) const
 {
-  int order = (o == -1) ? getPolynomialOrder() : o;
-  
-  switch (order) {
-  case 1: return BasisFactory::getJacobianBasis(MSH_LIN_2);
-  case 2: return BasisFactory::getJacobianBasis(MSH_LIN_3);
-  case 3: return BasisFactory::getJacobianBasis(MSH_LIN_4);
-  case 4: return BasisFactory::getJacobianBasis(MSH_LIN_5);
-  case 5: return BasisFactory::getJacobianBasis(MSH_LIN_6);
-  case 6: return BasisFactory::getJacobianBasis(MSH_LIN_7);
-  case 7: return BasisFactory::getJacobianBasis(MSH_LIN_8);
-  case 8: return BasisFactory::getJacobianBasis(MSH_LIN_9);
-  case 9: return BasisFactory::getJacobianBasis(MSH_LIN_10);
-  case 10: return BasisFactory::getJacobianBasis(MSH_LIN_11);
-  default: Msg::Error("Order %d line function space not implemented", order);
-  }
-  return 0;
+  if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
+
+  int tag = ElementType::getTag(TYPE_LIN, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
 void MLine::getIntegrationPoints(int pOrder, int *npts, IntPt **pts)
@@ -73,7 +48,7 @@ double MLine::getVolume()
   return getLength();
 }
 
-int MLine3::getNumEdgesRep() 
+int MLine3::getNumEdgesRep()
 {
   return  CTX::instance()->mesh.numSubEdges;
 }
@@ -90,7 +65,7 @@ void MLine3::getEdgeRep(int num, double *x, double *y, double *z, SVector3 *n)
   n[0] = n[1] = MEdge(_v[0], _v[1]).normal();
 }
 
-int MLineN::getNumEdgesRep() 
+int MLineN::getNumEdgesRep()
 {
   return  CTX::instance()->mesh.numSubEdges;
 }
diff --git a/Geo/MPrism.cpp b/Geo/MPrism.cpp
index 49456e2a6a16a0835d5922164f71ead5303880ad..beda50e53c21cf6f846fc010720235dbd20e8c48 100644
--- a/Geo/MPrism.cpp
+++ b/Geo/MPrism.cpp
@@ -36,40 +36,16 @@ const nodalBasis* MPrism::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_PRI_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_PRI_6);
-    case 2: return BasisFactory::getNodalBasis(MSH_PRI_18);
-    case 3: return BasisFactory::getNodalBasis(MSH_PRI_40);
-    case 4: return BasisFactory::getNodalBasis(MSH_PRI_75);
-    case 5: return BasisFactory::getNodalBasis(MSH_PRI_126);
-    case 6: return BasisFactory::getNodalBasis(MSH_PRI_196);
-    case 7: return BasisFactory::getNodalBasis(MSH_PRI_288);
-    case 8: return BasisFactory::getNodalBasis(MSH_PRI_405);
-    case 9: return BasisFactory::getNodalBasis(MSH_PRI_550);
-    default: Msg::Error("Order %d prism function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_PRI, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MPrism::getJacobianFuncSpace(int order) const
 {
   if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getJacobianBasis(MSH_PRI_1);
-    case 1: return BasisFactory::getJacobianBasis(MSH_PRI_6);
-    case 2: return BasisFactory::getJacobianBasis(MSH_PRI_18);
-    case 3: return BasisFactory::getJacobianBasis(MSH_PRI_40);
-    case 4: return BasisFactory::getJacobianBasis(MSH_PRI_75);
-    case 5: return BasisFactory::getJacobianBasis(MSH_PRI_126);
-    case 6: return BasisFactory::getJacobianBasis(MSH_PRI_196);
-    case 7: return BasisFactory::getJacobianBasis(MSH_PRI_288);
-    case 8: return BasisFactory::getJacobianBasis(MSH_PRI_405);
-    case 9: return BasisFactory::getJacobianBasis(MSH_PRI_550);
-    default: Msg::Error("Order %d prism function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_PRI, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
 double MPrism::getInnerRadius()
diff --git a/Geo/MPyramid.cpp b/Geo/MPyramid.cpp
index fb41b100d7e4eeedbf587f9dfb6a41ffbd8a8b64..6dc0d132b6620f469b2ae07d9be11ee10c15da4c 100644
--- a/Geo/MPyramid.cpp
+++ b/Geo/MPyramid.cpp
@@ -37,20 +37,8 @@ const nodalBasis* MPyramid::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_PYR_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_PYR_5);
-    case 2: return BasisFactory::getNodalBasis(MSH_PYR_14);
-    case 3: return BasisFactory::getNodalBasis(MSH_PYR_30);
-    case 4: return BasisFactory::getNodalBasis(MSH_PYR_55);
-    case 5: return BasisFactory::getNodalBasis(MSH_PYR_91);
-    case 6: return BasisFactory::getNodalBasis(MSH_PYR_140);
-    case 7: return BasisFactory::getNodalBasis(MSH_PYR_204);
-    case 8: return BasisFactory::getNodalBasis(MSH_PYR_285);
-    case 9: return BasisFactory::getNodalBasis(MSH_PYR_385);
-    default: Msg::Error("Order %d pyramid function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_PYR, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MPyramid::getJacobianFuncSpace(int o) const
diff --git a/Geo/MQuadrangle.cpp b/Geo/MQuadrangle.cpp
index 221208c787d0c67b2b72957dd852715ebd86f852..8f968870e545b4f5ff28478634cdf8ec00ed4713 100644
--- a/Geo/MQuadrangle.cpp
+++ b/Geo/MQuadrangle.cpp
@@ -21,40 +21,16 @@ const nodalBasis* MQuadrangle::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_QUA_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_QUA_4);
-    case 2: return BasisFactory::getNodalBasis(MSH_QUA_9);
-    case 3: return BasisFactory::getNodalBasis(MSH_QUA_16);
-    case 4: return BasisFactory::getNodalBasis(MSH_QUA_25);
-    case 5: return BasisFactory::getNodalBasis(MSH_QUA_36);
-    case 6: return BasisFactory::getNodalBasis(MSH_QUA_49);
-    case 7: return BasisFactory::getNodalBasis(MSH_QUA_64);
-    case 8: return BasisFactory::getNodalBasis(MSH_QUA_81);
-    case 9: return BasisFactory::getNodalBasis(MSH_QUA_100);
-    case 10: return BasisFactory::getNodalBasis(MSH_QUA_121);
-    default: Msg::Error("Order %d quadrangle function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_QUA, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MQuadrangle::getJacobianFuncSpace(int order) const
 {
   if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
-  switch (order) {
-    case 1: return BasisFactory::getJacobianBasis(MSH_QUA_4);
-    case 2: return BasisFactory::getJacobianBasis(MSH_QUA_9);
-    case 3: return BasisFactory::getJacobianBasis(MSH_QUA_16);
-    case 4: return BasisFactory::getJacobianBasis(MSH_QUA_25);
-    case 5: return BasisFactory::getJacobianBasis(MSH_QUA_36);
-    case 6: return BasisFactory::getJacobianBasis(MSH_QUA_49);
-    case 7: return BasisFactory::getJacobianBasis(MSH_QUA_64);
-    case 8: return BasisFactory::getJacobianBasis(MSH_QUA_81);
-    case 9: return BasisFactory::getJacobianBasis(MSH_QUA_100);
-    case 10: return BasisFactory::getJacobianBasis(MSH_QUA_121);
-    default: Msg::Error("Order %d quadrangle function space not implemented", order);
-  }
-  return 0;
+
+  int tag = ElementType::getTag(TYPE_QUA, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
 int MQuadrangleN::getNumEdgesRep(){ return 4 * CTX::instance()->mesh.numSubEdges; }
diff --git a/Geo/MTetrahedron.cpp b/Geo/MTetrahedron.cpp
index 6b4e3c7b16b012a637198abf88de6f9b4d2bf418..4a542fad8c2271121137168e0e17698424013df5 100644
--- a/Geo/MTetrahedron.cpp
+++ b/Geo/MTetrahedron.cpp
@@ -104,41 +104,16 @@ const nodalBasis* MTetrahedron::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_TET_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_TET_4);
-    case 2: return BasisFactory::getNodalBasis(MSH_TET_10);
-    case 3: return BasisFactory::getNodalBasis(MSH_TET_20);
-    case 4: return BasisFactory::getNodalBasis(MSH_TET_35);
-    case 5: return BasisFactory::getNodalBasis(MSH_TET_56);
-    case 6: return BasisFactory::getNodalBasis(MSH_TET_84);
-    case 7: return BasisFactory::getNodalBasis(MSH_TET_120);
-    case 8: return BasisFactory::getNodalBasis(MSH_TET_165);
-    case 9: return BasisFactory::getNodalBasis(MSH_TET_220);
-    case 10: return BasisFactory::getNodalBasis(MSH_TET_286);
-    default: Msg::Error("Order %d tetrahedron function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_TET, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MTetrahedron::getJacobianFuncSpace(int order) const
 {
   if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
 
-  switch (order) {
-    case 1: return BasisFactory::getJacobianBasis(MSH_TET_4);
-    case 2: return BasisFactory::getJacobianBasis(MSH_TET_10);
-    case 3: return BasisFactory::getJacobianBasis(MSH_TET_20);
-    case 4: return BasisFactory::getJacobianBasis(MSH_TET_35);
-    case 5: return BasisFactory::getJacobianBasis(MSH_TET_56);
-    case 6: return BasisFactory::getJacobianBasis(MSH_TET_84);
-    case 7: return BasisFactory::getJacobianBasis(MSH_TET_120);
-    case 8: return BasisFactory::getJacobianBasis(MSH_TET_165);
-    case 9: return BasisFactory::getJacobianBasis(MSH_TET_220);
-    case 10: return BasisFactory::getJacobianBasis(MSH_TET_286);
-    default: Msg::Error("Order %d tetrahedron function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_TET, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
 int MTetrahedron10::getNumEdgesRep(){ return 6 * CTX::instance()->mesh.numSubEdges; }
diff --git a/Geo/MTriangle.cpp b/Geo/MTriangle.cpp
index c8579331971e5efb72a32730ef665c678194fa88..4c26f5cd093f7d20992f5a8daaa8fa681c4a7c4c 100644
--- a/Geo/MTriangle.cpp
+++ b/Geo/MTriangle.cpp
@@ -123,41 +123,16 @@ const nodalBasis* MTriangle::getFunctionSpace(int order) const
 {
   if (order == -1) return BasisFactory::getNodalBasis(getTypeForMSH());
 
-  switch (order) {
-    case 0: return BasisFactory::getNodalBasis(MSH_TRI_1);
-    case 1: return BasisFactory::getNodalBasis(MSH_TRI_3);
-    case 2: return BasisFactory::getNodalBasis(MSH_TRI_6);
-    case 3: return BasisFactory::getNodalBasis(MSH_TRI_10);
-    case 4: return BasisFactory::getNodalBasis(MSH_TRI_15);
-    case 5: return BasisFactory::getNodalBasis(MSH_TRI_21);
-    case 6: return BasisFactory::getNodalBasis(MSH_TRI_28);
-    case 7: return BasisFactory::getNodalBasis(MSH_TRI_36);
-    case 8: return BasisFactory::getNodalBasis(MSH_TRI_45);
-    case 9: return BasisFactory::getNodalBasis(MSH_TRI_55);
-    case 10: return BasisFactory::getNodalBasis(MSH_TRI_66);
-    default: Msg::Error("Order %d triangle function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_TRI, order);
+  return tag ? BasisFactory::getNodalBasis(tag) : NULL;
 }
 
 const JacobianBasis* MTriangle::getJacobianFuncSpace(int order) const
 {
   if (order == -1) return BasisFactory::getJacobianBasis(getTypeForMSH());
 
-  switch (order) {
-    case 1: return BasisFactory::getJacobianBasis(MSH_TRI_3);
-    case 2: return BasisFactory::getJacobianBasis(MSH_TRI_6);
-    case 3: return BasisFactory::getJacobianBasis(MSH_TRI_10);
-    case 4: return BasisFactory::getJacobianBasis(MSH_TRI_15);
-    case 5: return BasisFactory::getJacobianBasis(MSH_TRI_21);
-    case 6: return BasisFactory::getJacobianBasis(MSH_TRI_28);
-    case 7: return BasisFactory::getJacobianBasis(MSH_TRI_36);
-    case 8: return BasisFactory::getJacobianBasis(MSH_TRI_45);
-    case 9: return BasisFactory::getJacobianBasis(MSH_TRI_55);
-    case 10: return BasisFactory::getJacobianBasis(MSH_TRI_66);
-    default: Msg::Error("Order %d triangle function space not implemented", order);
-  }
-  return NULL;
+  int tag = ElementType::getTag(TYPE_TRI, order);
+  return tag ? BasisFactory::getJacobianBasis(tag) : NULL;
 }
 
 int MTriangleN::getNumEdgesRep(){ return 3 * CTX::instance()->mesh.numSubEdges; }