** ReferenceSpace:

     -- Minimal number of reference space (at least for tet, tri and quad)
     -- Automatic generation of these reference space
     -- New interface
     -- Modification of TriNodeBasis accordingly

** Need to compute Dof permutations automaticaly

** All Basis are commented (exept for TriNodeBasis)

** WARNING: Memory leak somewhere

FunctionSpace/TetNedelecBasis.cpp

@@ -4,6 +4,7 @@
 using namespace std;
 
 TetNedelecBasis::TetNedelecBasis(void){
+  /*
   // Reference Space //
   refSpace  = new TetReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -66,9 +67,11 @@ TetNedelecBasis::TetNedelecBasis(void){
       basis[s][e] = new vector<Polynomial>(tmp2);
     }
   }
+  */
 }
 
 TetNedelecBasis::~TetNedelecBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -81,4 +84,5 @@ TetNedelecBasis::~TetNedelecBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/TetNodeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 TetNodeBasis::TetNodeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new TetReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -154,9 +155,11 @@ TetNodeBasis::TetNodeBasis(unsigned int order){
   delete[] legendre;
   delete[] sclLegendre;
   delete[] intLegendre;
+  */
 }
 
 TetNodeBasis::~TetNodeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -169,4 +172,5 @@ TetNodeBasis::~TetNodeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/TetReferenceSpace.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 TetReferenceSpace::TetReferenceSpace(void){
+  /*
   // Vertex Definition //
   nVertex = 4;
 
@@ -40,9 +41,11 @@ TetReferenceSpace::TetReferenceSpace(void){
 
   // Init All //
   init();
+  */
 }
 
 TetReferenceSpace::~TetReferenceSpace(void){
+  /*
   // Delete Ref Edge //
   for(size_t i = 0; i < nEdge; i++)
     delete[] refEdge[i];
@@ -55,13 +58,14 @@ TetReferenceSpace::~TetReferenceSpace(void){
 
   delete[] refFace;
   delete[] nNodeInFace;
+  */
 }
 
 string TetReferenceSpace::toLatex(void) const{
-  const size_t   nPerm = pTree->getNPermutation();
+  //const size_t   nPerm = pTree->getNPermutation();
   stringstream   stream;
-  vector<size_t> perm;
-
+  //vector<size_t> perm;
+  /*
   stream << "\\documentclass{article}" << endl << endl
 
          << "\\usepackage{longtable}"  << endl
@@ -101,6 +105,6 @@ string TetReferenceSpace::toLatex(void) const{
 
   stream << "\\end{longtable}" << endl
          << "\\end{document}"  << endl;
-
+  */
   return stream.str();
 }

FunctionSpace/TriEdgeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 TriEdgeBasis::TriEdgeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new TriReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -235,9 +236,11 @@ TriEdgeBasis::TriEdgeBasis(unsigned int order){
   delete[] u;
   delete[] v;
   delete[] subGrad;
+  */
 }
 
 TriEdgeBasis::~TriEdgeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -250,4 +253,5 @@ TriEdgeBasis::~TriEdgeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/TriLagrangeReferenceSpace.cpp

@@ -4,6 +4,7 @@
 using namespace std;
 
 TriLagrangeReferenceSpace::TriLagrangeReferenceSpace(unsigned int order){
+  /*
   // Vertex Definition //
   nVertex = 3;
 
@@ -41,9 +42,11 @@ TriLagrangeReferenceSpace::TriLagrangeReferenceSpace(unsigned int order){
     nNodePerCell;
 
   getLagrangeNode();
+  */
 }
 
 TriLagrangeReferenceSpace::~TriLagrangeReferenceSpace(void){
+  /*
   // Delete Ref Edge //
   for(size_t i = 0; i < nEdge; i++)
     delete[] refEdge[i];
@@ -55,4 +58,5 @@ TriLagrangeReferenceSpace::~TriLagrangeReferenceSpace(void){
     delete[] refFace[i];
 
   delete[] refFace;
+  */
 }

FunctionSpace/TriNedelecBasis.cpp

@@ -4,6 +4,7 @@
 using namespace std;
 
 TriNedelecBasis::TriNedelecBasis(void){
+  /*
   // Reference Space //
   refSpace  = new TriReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -63,9 +64,11 @@ TriNedelecBasis::TriNedelecBasis(void){
       basis[s][e] = new vector<Polynomial>(tmp2);
     }
   }
+  */
 }
 
 TriNedelecBasis::~TriNedelecBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -78,4 +81,5 @@ TriNedelecBasis::~TriNedelecBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/TriNodeBasis.cpp

@@ -4,16 +4,16 @@
 
 using namespace std;
 
-TriNodeBasis::TriNodeBasis(unsigned int order){
+TriNodeBasis::TriNodeBasis(size_t order){
   // Reference Space //
   refSpace  = new TriReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
 
-  const vector<const vector<const vector<unsigned int>*>*>&
-    edgeV = refSpace->getAllEdge();
+  const vector<vector<vector<size_t> > >&
+    edgeIdx = refSpace->getEdgeNodeIndex();
 
-  const vector<const vector<const vector<unsigned int>*>*>&
-    faceV = refSpace->getAllFace();
+  const vector<vector<vector<size_t> > >&
+    faceIdx = refSpace->getFaceNodeIndex();
 
   // Set BasisTwo Type //
   this->order = order;
@@ -51,28 +51,28 @@ TriNodeBasis::TriNodeBasis(unsigned int order){
   // Basis //
   basis = new Polynomial**[nRefSpace];
 
-  for(unsigned int s = 0; s < nRefSpace; s++)
+  for(size_t s = 0; s < nRefSpace; s++)
     basis[s] = new Polynomial*[nFunction];
 
   // Vertex Based //
-  for(unsigned int s = 0; s < nRefSpace; s++){
+  for(size_t s = 0; s < nRefSpace; s++){
     basis[s][0] = new Polynomial(lagrange[0]);
     basis[s][1] = new Polynomial(lagrange[1]);
     basis[s][2] = new Polynomial(lagrange[2]);
   }
 
   // Edge Based //
-  for(unsigned int s = 0; s < nRefSpace; s++){
-    unsigned int i = nVertex;
+  for(size_t s = 0; s < nRefSpace; s++){
+    size_t i = nVertex;
 
-    for(unsigned int e = 0; e < 3; e++){
-      for(unsigned int l = 1; l < order; l++){
+    for(size_t e = 0; e < 3; e++){
+      for(size_t l = 1; l < order; l++){
         basis[s][i] =
-          new Polynomial(intLegendre[l].compose(lagrange[(*(*edgeV[s])[e])[1]] -
-                                                lagrange[(*(*edgeV[s])[e])[0]]
+          new Polynomial(intLegendre[l].compose(lagrange[edgeIdx[s][e][1]] -
+                                                lagrange[edgeIdx[s][e][0]]
                                                 ,
-                                                lagrange[(*(*edgeV[s])[e])[0]] +
-                                                lagrange[(*(*edgeV[s])[e])[1]]));
+                                                lagrange[edgeIdx[s][e][0]] +
+                                                lagrange[edgeIdx[s][e][1]]));
         i++;
       }
     }
@@ -80,30 +80,30 @@ TriNodeBasis::TriNodeBasis(unsigned int order){
 
   // Face Based //
 
-  // NB: We use (*(*faceV[s])[f])[]
+  // NB: We use (*(*faceIdx[s])[f])[]
   //     where f = 0, because triangles
   //     have only ONE face: the face '0'
   const int orderMinusTwo = order - 2;
 
-  for(unsigned int s = 0; s < nRefSpace; s++){
-    unsigned int i = nVertex + nEdge;
+  for(size_t s = 0; s < nRefSpace; s++){
+    size_t i = nVertex + nEdge;
 
     for(int l1 = 1; l1 < orderMinus; l1++){
       for(int l2 = 0; l2 + l1 - 1 < orderMinusTwo; l2++){
         basis[s][i] =
-          new Polynomial(intLegendre[l1].compose(lagrange[(*(*faceV[s])[0])[1]] -
-                                                 lagrange[(*(*faceV[s])[0])[0]]
+          new Polynomial(intLegendre[l1].compose(lagrange[faceIdx[s][0][1]] -
+                                                 lagrange[faceIdx[s][0][0]]
                                                  ,
-                                                 lagrange[(*(*faceV[s])[0])[0]] +
-                                                 lagrange[(*(*faceV[s])[0])[1]])
+                                                 lagrange[faceIdx[s][0][0]] +
+                                                 lagrange[faceIdx[s][0][1]])
                          *
 
-                         legendre[l2].compose((lagrange[(*(*faceV[s])[0])[2]] * 2)
+                         legendre[l2].compose((lagrange[faceIdx[s][0][2]] * 2)
                                               -
                                               Polynomial(1, 0, 0, 0))
                          *
 
-                         lagrange[(*(*faceV[s])[0])[2]]);
+                         lagrange[faceIdx[s][0][2]]);
         i++;
       }
     }
@@ -119,8 +119,8 @@ TriNodeBasis::~TriNodeBasis(void){
   delete refSpace;
 
   // Basis //
-  for(unsigned int i = 0; i < nRefSpace; i++){
-    for(unsigned int j = 0; j < nFunction; j++)
+  for(size_t i = 0; i < nRefSpace; i++){
+    for(size_t j = 0; j < nFunction; j++)
       delete basis[i][j];
 
     delete[] basis[i];

FunctionSpace/TriNodeBasis.h

@@ -20,7 +20,7 @@ class TriNodeBasis: public BasisHierarchical0From{
   //! @param order The order of the Basis
   //!
   //! Returns a new Node-Basis for Triangles of the given order
-  TriNodeBasis(unsigned int order);
+  TriNodeBasis(size_t order);
 
   //! Deletes this Basis
   //!

FunctionSpace/TriReferenceSpace.cpp

@@ -9,54 +9,33 @@ TriReferenceSpace::TriReferenceSpace(void){
   nVertex = 3;
 
   // Edge Definition //
-  nEdge   = 3;
-  refEdge = new size_t*[nEdge];
+  const size_t nEdge = 3;
+  refEdgeNodeIdx.resize(nEdge);
 
   for(size_t i = 0; i < nEdge; i++){
-    refEdge[i]    = new size_t[2];
-    refEdge[i][0] = MTriangle::edges_tri(i, 0);
-    refEdge[i][1] = MTriangle::edges_tri(i, 1);
+    refEdgeNodeIdx[i].resize(2); // Two Nodes per Edge
+    refEdgeNodeIdx[i][0] = MTriangle::edges_tri(i, 0);
+    refEdgeNodeIdx[i][1] = MTriangle::edges_tri(i, 1);
   }
 
   // Face Definition //
-  // Number of face
-  nFace = 1;
+  refFaceNodeIdx.resize(1);    // One Face per Triangle
+  refFaceNodeIdx[0].resize(3); // Three Nodes per Face
 
-  // Number of node per face
-  nNodeInFace    = new size_t[nFace];
-  nNodeInFace[0] = 3;
-
-  // Reference Face
-  refFace    = new size_t*[nFace];
-  refFace[0] = new size_t[3];
-
-  refFace[0][0] = 0;
-  refFace[0][1] = 1;
-  refFace[0][2] = 2;
+  refFaceNodeIdx[0][0] = 0;
+  refFaceNodeIdx[0][1] = 1;
+  refFaceNodeIdx[0][2] = 2;
 
   // Init All //
   init();
 }
 
 TriReferenceSpace::~TriReferenceSpace(void){
-  // Delete Ref Edge //
-  for(size_t i = 0; i < nEdge; i++)
-    delete[] refEdge[i];
-
-  delete[] refEdge;
-
-  // Delete Ref Face //
-  for(size_t i = 0; i < nFace; i++)
-    delete[] refFace[i];
-
-  delete[] refFace;
-  delete[] nNodeInFace;
 }
 
 string TriReferenceSpace::toLatex(void) const{
-  const size_t   nPerm = pTree->getNPermutation();
+  const size_t   nRefSpace = refSpaceNodeId.size();
   stringstream   stream;
-  vector<size_t> perm(nVertex);
 
   stream << "\\documentclass{article}" << endl << endl
 
@@ -70,24 +49,25 @@ string TriReferenceSpace::toLatex(void) const{
 
          << "\\begin{longtable}{ccc}" << endl << endl;
 
-  for(size_t p = 0; p < nPerm; p++){
-    pTree->fillWithPermutation(p, perm);
-
+  for(size_t s = 0; s < nRefSpace; s++){
     stream << "\\begin{tikzpicture}" << endl
 
-           << "\\node[vertex] (n0) at(0, 0) {$" << perm[0] << "$};" << endl
-           << "\\node[vertex] (n1) at(3, 0) {$" << perm[1] << "$};" << endl
-           << "\\node[vertex] (n2) at(0, 3) {$" << perm[2] << "$};" << endl
+           << "\\node[vertex] (n0) at(0, 0) {$" << refSpaceNodeId[s][0] << "$};"
+           << endl
+           << "\\node[vertex] (n1) at(3, 0) {$" << refSpaceNodeId[s][1] << "$};"
+           << endl
+           << "\\node[vertex] (n2) at(0, 3) {$" << refSpaceNodeId[s][2] << "$};"
+           << endl
            << endl;
 
-    for(size_t i = 0; i < 3; i++)
+    for(size_t e = 0; e < 3; e++)
       stream << "\\path[line]"
-             << " (n" << (*(*(*edge)[p])[i])[0] << ")"
+             << " (n" << orderedEdgeNodeIdx[s][e][0] << ")"
              << " -- "
-             << " (n" << (*(*(*edge)[p])[i])[1] << ");"
+             << " (n" << orderedEdgeNodeIdx[s][e][1] << ");"
              << endl;
 
-    if((p + 1) % 3)
+    if((s + 1) % 3)
       stream << "\\end{tikzpicture} & "        << endl << endl;
 
     else