** 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/Basis.h

@@ -81,6 +81,10 @@ class Basis{
   virtual unsigned int getNOrientation(void) const = 0;
   virtual unsigned int getOrientation(const MElement& element) const = 0;
 
+  virtual void mapFromXYZtoABC(const MElement& element,
+                               const fullVector<double>& xyz,
+                               double abc[3]) const = 0;
+
   // Functions Ordering //
   virtual std::vector<size_t>
     getFunctionOrdering(const MElement& element) const = 0;

FunctionSpace/BasisHierarchical0From.cpp

@@ -59,6 +59,12 @@ getOrientation(const MElement& element) const{
   return refSpace->getReferenceSpace(element);
 }
 
+void BasisHierarchical0From::mapFromXYZtoABC(const MElement& element,
+                                             const fullVector<double>& xyz,
+                                             double abc[3]) const{
+  return refSpace->mapFromXYZtoABC(element, xyz, abc);
+}
+
 vector<size_t> BasisHierarchical0From::
 getFunctionOrdering(const MElement& element) const{
   vector<size_t> ordering(nFunction);
@@ -66,6 +72,33 @@ getFunctionOrdering(const MElement& element) const{
   for(size_t i = 0; i < nFunction; i++)
     ordering[i] = i;
 
+  /*
+  if(element.getNum() == 5){
+    ordering[0] = 0;
+    ordering[1] = 1;
+    ordering[2] = 2;
+    ordering[3] = 3;
+    ordering[4] = 4;
+    ordering[5] = 5;
+    ordering[6] = 6;
+    ordering[7] = 7;
+    ordering[8] = 8;
+    ordering[9] = 9;
+  }
+
+  else{
+    ordering[0] = 2;
+    ordering[1] = 0;
+    ordering[2] = 1;
+    ordering[3] = 7;
+    ordering[4] = 8;
+    ordering[5] = 3;
+    ordering[6] = 4;
+    ordering[7] = 5;
+    ordering[8] = 6;
+    ordering[9] = 9;
+  }
+  */
   return ordering;
 }
 

FunctionSpace/BasisHierarchical0From.h

@@ -39,6 +39,10 @@ class BasisHierarchical0From: public BasisLocal{
   virtual unsigned int getNOrientation(void) const;
   virtual unsigned int getOrientation(const MElement& element) const;
 
+  virtual void mapFromXYZtoABC(const MElement& element,
+                               const fullVector<double>& xyz,
+                               double abc[3]) const;
+
   virtual std::vector<size_t>
     getFunctionOrdering(const MElement& element) const;
 

FunctionSpace/BasisHierarchical1From.cpp

@@ -59,6 +59,12 @@ getOrientation(const MElement& element) const{
   return refSpace->getReferenceSpace(element);
 }
 
+void BasisHierarchical1From::mapFromXYZtoABC(const MElement& element,
+                                             const fullVector<double>& xyz,
+                                             double abc[3]) const{
+  return refSpace->mapFromXYZtoABC(element, xyz, abc);
+}
+
 vector<size_t> BasisHierarchical1From::
 getFunctionOrdering(const MElement& element) const{
   vector<size_t> ordering(nFunction);

FunctionSpace/BasisHierarchical1From.h

@@ -39,6 +39,10 @@ class BasisHierarchical1From: public BasisLocal{
   virtual unsigned int getNOrientation(void) const;
   virtual unsigned int getOrientation(const MElement& element) const;
 
+  virtual void mapFromXYZtoABC(const MElement& element,
+                               const fullVector<double>& xyz,
+                               double abc[3]) const;
+
   virtual std::vector<size_t>
     getFunctionOrdering(const MElement& element) const;
 

FunctionSpace/BasisLagrange.cpp

@@ -78,6 +78,11 @@ static size_t matchClosure(vector<int>& reduced,
   return i;
 }
 
+void BasisLagrange::mapFromXYZtoABC(const MElement& element,
+                                    const fullVector<double>& xyz,
+                                    double abc[3]) const{
+}
+
 vector<size_t> BasisLagrange::
 getFunctionOrdering(const MElement& element) const{
   /*

FunctionSpace/BasisLagrange.h

@@ -43,6 +43,10 @@ class BasisLagrange: public BasisLocal{
   virtual unsigned int getNOrientation(void) const;
   virtual unsigned int getOrientation(const MElement& element) const;
 
+  virtual void mapFromXYZtoABC(const MElement& element,
+                               const fullVector<double>& xyz,
+                               double abc[3]) const;
+
   virtual std::vector<size_t>
     getFunctionOrdering(const MElement& element) const;
 

FunctionSpace/FunctionSpaceScalar.cpp

@@ -14,7 +14,7 @@ double FunctionSpaceScalar::
 interpolate(const MElement& element,
             const std::vector<double>& coef,
             const fullVector<double>& xyz) const{
-
+  /*
   // Const Cast For MElement //
   MElement& eelement =
     const_cast<MElement&>(element);
@@ -34,11 +34,11 @@ interpolate(const MElement& element,
   element.getNode(0, abcPnt[0][0], abcPnt[0][1], abcPnt[0][2]);
   element.getNode(1, abcPnt[1][0], abcPnt[1][1], abcPnt[1][2]);
   element.getNode(2, abcPnt[2][0], abcPnt[2][1], abcPnt[2][2]);
-  /*
+
   std::cout << order[0] << " | "
             << order[1] << " | "
             << order[2] << std::endl;
-  */
+
   abcMat[0][0] = abcPnt[0][0];
   abcMat[0][1] = abcPnt[1][0];
   abcMat[0][2] = abcPnt[2][0];
@@ -50,14 +50,14 @@ interpolate(const MElement& element,
   abcMat[2][0] = abcPnt[0][2];
   abcMat[2][1] = abcPnt[1][2];
   abcMat[2][2] = abcPnt[2][2];
-  /*
+
   for(size_t i = 0; i < 3; i++){
     for(size_t j = 0; j < 3; j++)
       std::cout << abcMat[i][j] << "\t";
     std::cout << std::endl;
   }
   std::cout << std::endl;
-  */
+
   double phiUVW[3];
   element.getShapeFunctions(uvw[0], uvw[1], uvw[2], phiUVW);
 
@@ -90,12 +90,17 @@ interpolate(const MElement& element,
   uvw[0] = abc[0];
   uvw[1] = abc[1];
   uvw[2] = abc[2];
+  */
+
+  // Get ABC Space coordinate //
+  double abc[3];
+  (*basis)[0]->mapFromXYZtoABC(element, xyz, abc);
 
   // Get Basis Functions //
   const unsigned int nFun = (*basis)[0]->getNFunction();
   fullMatrix<double>  fun(nFun, 1);
 
-  (*basis)[0]->getFunctions(fun, element, uvw[0], uvw[1], uvw[2]);
+  (*basis)[0]->getFunctions(fun, element, abc[0], abc[1], abc[2]);
 
   // Interpolate (in Reference Place) //
   double val = 0;

FunctionSpace/LineEdgeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 LineEdgeBasis::LineEdgeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new LineReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -71,9 +72,11 @@ LineEdgeBasis::LineEdgeBasis(unsigned int order){
 
   // Free Temporary Space //
   delete[] intLegendre;
+  */
 }
 
 LineEdgeBasis::~LineEdgeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -86,4 +89,5 @@ LineEdgeBasis::~LineEdgeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/LineNedelecBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 LineNedelecBasis::LineNedelecBasis(void){
+  /*
   // Reference Space //
   refSpace  = new LineReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -41,9 +42,11 @@ LineNedelecBasis::LineNedelecBasis(void){
   // Nedelec //
   basis[0][0] = new vector<Polynomial>(first);
   basis[1][0] = new vector<Polynomial>(second);
+  */
 }
 
 LineNedelecBasis::~LineNedelecBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -56,4 +59,5 @@ LineNedelecBasis::~LineNedelecBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/LineNodeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 LineNodeBasis::LineNodeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new LineReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -66,9 +67,11 @@ LineNodeBasis::LineNodeBasis(unsigned int order){
 
   // Free Temporary Sapce //
   delete[] intLegendre;
+  */
 }
 
 LineNodeBasis::~LineNodeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -81,4 +84,5 @@ LineNodeBasis::~LineNodeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/LineReferenceSpace.cpp

@@ -4,6 +4,7 @@
 using namespace std;
 
 LineReferenceSpace::LineReferenceSpace(void){
+  /*
   // Vertex Definition //
   nVertex = 2;
 
@@ -21,20 +22,23 @@ LineReferenceSpace::LineReferenceSpace(void){
 
   // Init All //
   init();
+  */
 }
 
 LineReferenceSpace::~LineReferenceSpace(void){
+  /*
   // Delete Ref Edge //
   for(size_t i = 0; i < nEdge; i++)
     delete[] refEdge[i];
 
   delete[] refEdge;
+  */
 }
 
 string LineReferenceSpace::toLatex(void) const{
-  const size_t nPerm = pTree->getNPermutation();
+  //const size_t nPerm = pTree->getNPermutation();
   stringstream stream;
-
+  /*
   stream << "\\documentclass{article}" << endl << endl
 
          << "\\usepackage{longtable}"  << endl
@@ -64,6 +68,6 @@ string LineReferenceSpace::toLatex(void) const{
 
   stream << "\\end{longtable}" << endl
          << "\\end{document}"  << endl;
-
+  */
   return stream.str();
 }

FunctionSpace/QuadEdgeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 QuadEdgeBasis::QuadEdgeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new QuadReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -238,9 +239,11 @@ QuadEdgeBasis::QuadEdgeBasis(unsigned int order){
   // Free Temporary Sapce //
   delete[] legendre;
   delete[] intLegendre;
+  */
 }
 
 QuadEdgeBasis::~QuadEdgeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -253,4 +256,5 @@ QuadEdgeBasis::~QuadEdgeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/QuadNedelecBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 QuadNedelecBasis::QuadNedelecBasis(void){
+  /*
   // Reference Space //
   refSpace  = new QuadReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -105,9 +106,11 @@ QuadNedelecBasis::QuadNedelecBasis(void){
       delete old;
     }
   }
+  */
 }
 
 QuadNedelecBasis::~QuadNedelecBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -120,4 +123,5 @@ QuadNedelecBasis::~QuadNedelecBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/QuadNodeBasis.cpp

@@ -5,6 +5,7 @@
 using namespace std;
 
 QuadNodeBasis::QuadNodeBasis(unsigned int order){
+  /*
   // Reference Space //
   refSpace  = new QuadReferenceSpace;
   nRefSpace = refSpace->getNReferenceSpace();
@@ -142,9 +143,11 @@ QuadNodeBasis::QuadNodeBasis(unsigned int order){
 
   // Free Temporary Sapce //
   delete[] legendre;
+  */
 }
 
 QuadNodeBasis::~QuadNodeBasis(void){
+  /*
   // ReferenceSpace //
   delete refSpace;
 
@@ -157,4 +160,5 @@ QuadNodeBasis::~QuadNodeBasis(void){
   }
 
   delete[] basis;
+  */
 }

FunctionSpace/QuadReferenceSpace.cpp

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

FunctionSpace/ReferenceSpace.h

@@ -3,10 +3,10 @@
 
 #include <vector>
 #include <list>
-#include <stack>
 #include <string>
 
 #include "MElement.h"
+#include "fullMatrix.h"
 #include "PermutationTree.h"
 
 /**
@@ -28,70 +28,51 @@ class ReferenceSpace{
   } triple;
 
  protected:
+  // Element Definition //
+  size_t nVertex;
+  std::vector<std::vector<size_t> > refEdgeNodeIdx;
+  std::vector<std::vector<size_t> > refFaceNodeIdx;
+
   // Permutation Tree //
   PermutationTree* pTree;
 
-  //////////////////////////////////////////////////////////////////////////
-  // !!! CHANGE VARIABLES NAME !!!                                        //
-  //                                                                      //
-  // perm              = nodeReducedGlobalId                              //
-  // refEntity         = entityNodeIndex                                  //
-  // entity            = orientedEntityNodeIndex                          //
-  //                                                                      //
-  // !!! I'm Working on *BOTH* indexes and global IDs !!!                 //
-  //                                                                      //
-  // 16 +                                                                 //
-  //    |\        ---> NodeIndex       = [v0 v1 v2]                       //
-  //    | \       ---> GlobalID        = [17 42 16]                       //
-  //    |  \      ---> ReducedGlobalId = [1  2  0 ] ---> Permutation = 3  //
-  // 17 +---+ 42                                                          //
-  //                                                                      //
-  // *  refEdge[e][i] = ith INDEX of edge[e]                              //
-  //    For example refEdge[1] = [1 2] because edge[1]                    //
-  //                              - -                                     //
-  //                                           is made of nodes v1 and v2 //
-  //                                                             -      - //
-  //                                                                      //
-  // *  edge[p][e][i] = ith INDEX of edge[e] in orientation[p]            //
-  //          such that GlobalID[edge[p][e][0]] > GlobalId[edge[p][e][0]] //
-  //    For example edge[3][1] = [2 1] because edge[1] goes from v2 to v1 //
-  //                              - -                             -     - //
-  //////////////////////////////////////////////////////////////////////////
-
-  // Number of Vertices //
-  size_t nVertex;
+  // Reference Spaces Node Ids //
+  std::vector<std::vector<size_t> > refSpaceNodeId;
 
-  // Edge Permutation //
-  size_t    nEdge;
-  size_t**  refEdge;
-  //unsigned int*** permutedRefEdge;
-  std::vector<const std::vector<const std::vector<unsigned int>*>*>* edge;
+  // ABC space to UVW space shape function index mapping //
+  std::vector<std::vector<size_t> > ABCtoUVWIndex;
 
-  // Face Permutation //
-  size_t    nFace;
-  size_t*   nNodeInFace;
-  size_t**  refFace;
-  //unsigned int*** permutedRefFace;
-  std::vector<const std::vector<const std::vector<unsigned int>*>*>* face;
+  // UVW space to ABC space shape function index mapping //
+  std::vector<std::vector<size_t> > UVWtoABCIndex;
+
+  // Ordered Edge & Face Node Index //
+  std::vector<std::vector<std::vector<size_t> > > orderedEdgeNodeIdx;
+  std::vector<std::vector<std::vector<size_t> > > orderedFaceNodeIdx;
 
  public:
   virtual ~ReferenceSpace(void);
 
   size_t getNReferenceSpace(void) const;
-
   size_t getReferenceSpace(const MElement& element) const;
-  /*
-  std::vector<std::vector<size_t> > getEdgeIndex(size_t referenceSpaceId) const;
-  std::vector<std::vector<size_t> > getFaceIndex(size_t referenceSpaceId) const;
-  */
-  const std::vector<const std::vector<const std::vector<unsigned int>*>*>&
-    getAllEdge(void) const;
 
-  const std::vector<const std::vector<const std::vector<unsigned int>*>*>&
-    getAllFace(void) const;
+  const std::vector<std::vector<size_t> >&
+    getNodeId(void) const;
 
-  virtual std::string toString(void) const;
+  const std::vector<std::vector<std::vector<size_t> > >&
+    getEdgeNodeIndex(void) const;
+
+  const std::vector<std::vector<std::vector<size_t> > >&
+    getFaceNodeIndex(void) const;
+
+  void mapFromXYZtoABC(const MElement& element,
+                       const fullVector<double>& xyz,
+                       double abc[3]);
+
+  void getJacobian(const MElement& element,
+                   const fullVector<double>& xyz,
+                   fullMatrix<double>& jac) const;
 
+  virtual std::string toString(void) const;
   virtual std::string toLatex(void) const;
 
  protected:
@@ -99,38 +80,32 @@ class ReferenceSpace{
 
   void init(void);
 
-  void getEdge(void);
-  void getFace(void);
+  void getOrderedEdge(void);
+  void getOrderedFace(void);
+
+  void findCyclicPermutation
+    (std::list<size_t>&               listOfTrueReferenceSpace,
+     std::list<std::vector<size_t> >& listOfRefNodeIndexPermutation,
+     std::list<std::vector<size_t> >& listOfReverseNodeIndexPermutation);
 
-  void   findCyclicPermutation(void);
   triple isCyclicPermutation(std::vector<size_t>& pTest,
                              std::vector<size_t>& pRef);
 
   size_t findCorrespondingFace(std::vector<size_t>& face,
                                std::vector<size_t>& node);
 
-  /*
-  void getPermutedRefEntity(unsigned int**** permutedRefEntity,
-                            unsigned int**   refEntity,
-                            unsigned int*    nNodeInEntity,
-                            unsigned int     nEntity);
-  */
-  const std::vector<unsigned int>* getOrderedEdge(unsigned int permutation,
-                                                  unsigned int edge);
-
-  const std::vector<unsigned int>* getOrderedTriFace(unsigned int permutation,
-                                                     unsigned int face);
-
-  const std::vector<unsigned int>* getOrderedQuadFace(unsigned int permutation,
-                                                      unsigned int face);
+  static void
+    orderRefEntityForGivenRefSpace(std::vector<size_t>& refEntityNodeIdx,
+                                   std::vector<size_t>& refSpaceNodeId,
+                                   std::vector<size_t>& orderedEntityNodeIdx);
 
   static void
-    orderRefEntityForGivenPermutation(size_t* refEntity,
-                                      std::vector<size_t>& permutation,
-                                      std::vector<unsigned int>& orderedEntity);
+    correctQuadFaceNodeIdx(std::vector<size_t>& correctedQuadFaceNodeIdx);
+
+  size_t getPermutationIdx(const MElement& element) const;
 
-  static bool sortPredicate(const std::pair<unsigned int, unsigned int>& a,
-                            const std::pair<unsigned int, unsigned int>& b);
+  static bool sortPredicate(const std::pair<size_t, size_t>& a,
+                            const std::pair<size_t, size_t>& b);
 };
 
 
@@ -198,26 +173,30 @@ class ReferenceSpace{
 //////////////////////
 
 inline size_t ReferenceSpace::getNReferenceSpace(void) const{
-  return pTree->getNPermutation();
+  return refSpaceNodeId.size();
 }
 
 inline
-const std::vector<const std::vector<const std::vector<unsigned int>*>*>&
-ReferenceSpace::getAllEdge(void) const{
-  return *edge;
+const std::vector<std::vector<std::vector<size_t> > >&
+ReferenceSpace::getEdgeNodeIndex(void) const{
+  return orderedEdgeNodeIdx;
 }
 
 inline
-const std::vector<const std::vector<const std::vector<unsigned int>*>*>&
-ReferenceSpace::getAllFace(void) const{
-  return *face;
+const std::vector<std::vector<std::vector<size_t> > >&
+ReferenceSpace::getFaceNodeIndex(void) const{
+  return orderedFaceNodeIdx;
 }
 
+inline
+size_t ReferenceSpace::getReferenceSpace(const MElement& element) const{
+  return pTree->getTagFromPermutation(getPermutationIdx(element));
+}
 
 inline
 bool
-ReferenceSpace::sortPredicate(const std::pair<unsigned int, unsigned int>& a,
-                              const std::pair<unsigned int, unsigned int>& b){
+ReferenceSpace::sortPredicate(const std::pair<size_t, size_t>& a,
+                              const std::pair<size_t, size_t>& b){
   return a.second < b.second;
 }
 

FunctionSpace/ReferenceSpaceLagrange.cpp

@@ -21,6 +21,7 @@ ReferenceSpaceLagrange::~ReferenceSpaceLagrange(void){
 }
 
 void ReferenceSpaceLagrange::getLagrangeNode(void){
+  /*
   const size_t nPerm = pTree->getNPermutation();
 
   // Alloc //
@@ -58,6 +59,7 @@ void ReferenceSpaceLagrange::getLagrangeNode(void){
     // Insert in node
     (*node)[p] = tmp;
   }
+  */
 }
 
 void ReferenceSpaceLagrange::edgeSeq(vector<unsigned int>& vec,

FunctionSpace/TetEdgeBasis.cpp

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