diff --git a/FunctionSpace/FunctionSpace.cpp b/FunctionSpace/FunctionSpace.cpp
index 874cafc5b94980648b2a3914e0d718926c906745..ea38989248cde6e218e375ca66a39d0d5b4b9f56 100644
--- a/FunctionSpace/FunctionSpace.cpp
+++ b/FunctionSpace/FunctionSpace.cpp
@@ -1,6 +1,7 @@
#include <sstream>
#include "FunctionSpace.h"
#include "BasisGenerator.h"
+#include "ElementType.h"
#include "Exception.h"
using namespace std;
@@ -161,8 +162,10 @@ vector<Dof> FunctionSpace::getKeys(const MElement& elem) const{
// New Element
MElementFactory factory;
- //MElement* permElement = factory.create(elem.getLowOrderTypeForMSH(), vertex);
- MElement* permElement = factory.create(elem.getTypeForMSH(), vertex);
+ int parentTag = ElementType::ParentTypeFromTag(elem.getTypeForMSH());
+ int lowOrderTag = ElementType::getTag(parentTag, 1, false);
+
+ MElement* permElement = factory.create(lowOrderTag, vertex);
// Edge & Face from Permuted Element //
const size_t nEdge = permElement->getNumEdges();
diff --git a/FunctionSpace/ReferenceSpace.cpp b/FunctionSpace/ReferenceSpace.cpp
index b139e837da3be53d549eb3135df0148cd4f207db..d11afb6f8101b636ecf0827ad51c8cc5103d468b 100644
--- a/FunctionSpace/ReferenceSpace.cpp
+++ b/FunctionSpace/ReferenceSpace.cpp
@@ -75,7 +75,7 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
list<size_t>::iterator it;
list<size_t>::iterator end;
- triple match;
+ triplet match;
// Values For unPermutedIndex //
vector<size_t> unPermutedIndex(nVertex);
@@ -126,13 +126,13 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
}
}
-ReferenceSpace::triple ReferenceSpace::
+ReferenceSpace::triplet ReferenceSpace::
isCyclicPermutation(vector<size_t>& pTest,
vector<size_t>& pRef){
// If no Face, we have no Cyclic Permutation
if(!refFaceNodeIdx.size()){
- triple tri = {
+ triplet tri = {
false,
vector<size_t>(0),
vector<size_t>(0)
@@ -151,6 +151,17 @@ isCyclicPermutation(vector<size_t>& pTest,
// Corresponding Face in Test Permutation
size_t testFaceId = findCorrespondingFace(refNode, pTest);
+ // If no corresponding face found, we have no Cyclic Permutation
+ if(testFaceId == (size_t)(-1)){
+ triplet tri = {
+ false,
+ vector<size_t>(0),
+ vector<size_t>(0)
+ };
+
+ return tri;
+ }
+
// Node IDs of Test Permutation correspnding Face
const size_t nNodeInFaceTest = refFaceNodeIdx[testFaceId].size();
vector<size_t> testNode(nNodeInFaceTest);
@@ -158,8 +169,8 @@ isCyclicPermutation(vector<size_t>& pTest,
for(size_t i = 0; i < nNodeInFaceTest; i++)
testNode[i] = pTest[refFaceNodeIdx[testFaceId][i]];
- // Return Triple
- triple tri = {
+ // Return Triplet
+ triplet tri = {
isFacePermutation(refNode, testNode),
getRefIndexPermutation(pRef, pTest),
getReverseIndexPermutation(pRef, pTest)
@@ -196,38 +207,38 @@ size_t ReferenceSpace::findCorrespondingFace(vector<size_t>& face,
f++;
}
- return f;
+ // If a valid face is found return it
+ if(f < nFace)
+ return f;
+
+ // Else return (size_t)(-1)
+ else
+ return -1;
}
bool ReferenceSpace::isFacePermutation(vector<size_t>& refNode,
vector<size_t>& testNode){
+ // Check Size
const size_t size = refNode.size();
- bool match = false;
if(size != testNode.size())
return false;
- for(size_t i = 0; i < size && !match; i++){
- bool submatch = true;
+ // Find refNode[0] in testNode
+ size_t offset = 0;
- for(size_t j = 0; j < size && submatch; j++)
- if(refNode[j] != testNode[j])
- submatch = false;
+ while(refNode[0] != testNode[offset] && offset < size)
+ offset++;
- if(!submatch){
- size_t tmp0 = testNode[0];
- size_t tmp1 = testNode[1];
+ // If refNode[0] not found in testNode, there is no face permutation
+ if(offset == size)
+ return false;
- for(size_t k = 1; k < size + 1; k++){
- testNode[k % size] = tmp0;
- tmp0 = tmp1;
- tmp1 = testNode[(k + 1) % size];
- }
- }
+ // Check refNode[i] and testNode[(i + offset) % size]
+ bool match = true;
- else
- match = true;
- }
+ for(size_t i = 0; i < size && match; i++)
+ match = (refNode[i] == testNode[(i + offset) % size]);
return match;
}
@@ -268,23 +279,25 @@ vector<size_t> ReferenceSpace::getReverseIndexPermutation(vector<size_t>& ref,
return idxVec;
}
-bool ReferenceSpace::haveSameNode(vector<size_t>& face0,
- vector<size_t>& face1){
+bool ReferenceSpace::haveSameNode(vector<size_t> face0,
+ vector<size_t> face1){
+ // Check Sizes
const size_t size = face0.size();
- bool matchIsPossible = true;
- for(size_t i = 0; i < size && matchIsPossible; i++){
- bool submatch = false;
+ if(size != face1.size())
+ return false;
- for(size_t j = 0; j < size && !submatch; j++){
- if(face0[i] == face1[j])
- submatch = true;
- }
+ // Sort both vectors
+ sort(face0.begin(), face0.end());
+ sort(face1.begin(), face1.end());
- matchIsPossible = submatch;
- }
+ // Check if elements are the same and at same position
+ bool match = true;
- return matchIsPossible;
+ for(size_t i = 0; i < size && match; i++)
+ match = (face0[i] == face1[i]);
+
+ return match;
}
void ReferenceSpace::getOrderedEdge(void){
diff --git a/FunctionSpace/ReferenceSpace.h b/FunctionSpace/ReferenceSpace.h
index 04b740d8551573d1f4f9079e458a4d4b0328520e..1518a1fbec100df947e110bc69ae4433d698ecef 100644
--- a/FunctionSpace/ReferenceSpace.h
+++ b/FunctionSpace/ReferenceSpace.h
@@ -25,7 +25,7 @@ class ReferenceSpace{
bool first;
std::vector<size_t> second;
std::vector<size_t> third;
- } triple;
+ } triplet;
protected:
// Element Definition //
@@ -101,8 +101,8 @@ class ReferenceSpace{
std::list<std::vector<size_t> >& listOfRefNodeIndexPermutation,
std::list<std::vector<size_t> >& listOfReverseNodeIndexPermutation);
- triple isCyclicPermutation(std::vector<size_t>& pTest,
- std::vector<size_t>& pRef);
+ triplet isCyclicPermutation(std::vector<size_t>& pTest,
+ std::vector<size_t>& pRef);
size_t findCorrespondingFace(std::vector<size_t>& face,
std::vector<size_t>& node);
@@ -116,8 +116,8 @@ class ReferenceSpace{
std::vector<size_t> getReverseIndexPermutation(std::vector<size_t>& ref,
std::vector<size_t>& test);
- static bool haveSameNode(std::vector<size_t>& face0,
- std::vector<size_t>& face1);
+ static bool haveSameNode(std::vector<size_t> face0,
+ std::vector<size_t> face1);
size_t getPermutationIdx(const MElement& element) const;