Skip to content
Snippets Groups Projects
Commit 1e704e72 authored by Nicolas Marsic's avatar Nicolas Marsic
Browse files

** 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
parent ca29a67a
No related branches found
No related tags found
No related merge requests found
Showing
with 409 additions and 362 deletions
......@@ -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;
......
......@@ -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;
}
......
......@@ -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;
......
......@@ -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);
......
......@@ -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;
......
......@@ -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{
/*
......
......@@ -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;
......
......@@ -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;
......
......@@ -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;
*/
}
......@@ -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;
*/
}
......@@ -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;
*/
}
......@@ -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();
}
......@@ -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;
*/
}
......@@ -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;
*/
}
......@@ -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;
*/
}
......@@ -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();
}
This diff is collapsed.
......@@ -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;
}
......
......@@ -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,
......
......@@ -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;
*/
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment