From 54282dc9338bb8a8faab69fceee01c5ec5e26fd8 Mon Sep 17 00:00:00 2001
From: Nicolas Marsic <nicolas.marsic@gmail.com>
Date: Tue, 8 Apr 2014 12:41:50 +0000
Subject: [PATCH] Removing cyclic permutation stuffs from ReferenceSpace (only
connectivity is used now)
---
FunctionSpace/ReferenceSpace.cpp | 161 +++-------------------------
FunctionSpace/ReferenceSpace.h | 15 +--
FunctionSpace/TriReferenceSpace.cpp | 15 ---
FunctionSpace/TriReferenceSpace.h | 3 -
4 files changed, 20 insertions(+), 174 deletions(-)
diff --git a/FunctionSpace/ReferenceSpace.cpp b/FunctionSpace/ReferenceSpace.cpp
index bdd10dc17e..d54c03c268 100644
--- a/FunctionSpace/ReferenceSpace.cpp
+++ b/FunctionSpace/ReferenceSpace.cpp
@@ -32,14 +32,14 @@ void ReferenceSpace::init(void){
pTree = new PermutationTree(vertexSeq);
- // Cyclic Permutation //
+ // Connectivity //
list<size_t> listOfTrueReferenceSpace;
list<vector<size_t> > listOfRefNodeIndexPermutation;
list<vector<size_t> > listOfReverseNodeIndexPermutation;
- findCyclicPermutation(listOfTrueReferenceSpace,
- listOfRefNodeIndexPermutation,
- listOfReverseNodeIndexPermutation);
+ findConnectivity(listOfTrueReferenceSpace,
+ listOfRefNodeIndexPermutation,
+ listOfReverseNodeIndexPermutation);
// Iterators //
list<size_t>::iterator refSpaceIt = listOfTrueReferenceSpace.begin();
@@ -132,9 +132,10 @@ void ReferenceSpace::init(const std::string& path){
}
void ReferenceSpace::
-findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
- list<vector<size_t> >& listOfRefNodeIndexPermutation,
- list<vector<size_t> >& listOfReverseNodeIndexPermutation){
+findConnectivity(list<size_t>& listOfTrueReferenceSpace,
+ list<vector<size_t> >& listOfRefNodeIndexPermutation,
+ list<vector<size_t> >& listOfReverseNodeIndexPermutation){
+
// Alloc Some Data //
const size_t nPerm = pTree->getNPermutation();
@@ -151,7 +152,7 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
for(size_t i = 0; i < nVertex; i++)
unPermutedIndex[i] = i;
- // Find Cyclic Permutation //
+ // Find Connectivity //
for(size_t i = 0; i < nPerm; i++){
// No match
match.first = false;
@@ -167,8 +168,8 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
// Take Reference Space 'it'
pTree->fillWithPermutation(*it, pRef);
- // Look if it matches
- match = isCyclicPermutation(pTest, pRef);
+ // Look if it matches (do pTest and pRef have the same connectivity ?)
+ match = isSameConnectivity(pTest, pRef);
// If not, go to next Reference Space
if(!match.first)
@@ -186,7 +187,7 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
pTree->addTagToPermutation(i, i);
}
- // If a ReferenceSpace is found, and the index permutations
+ // If a ReferenceSpace is found, add the index permutations
else{
listOfRefNodeIndexPermutation.push_back(match.second);
listOfReverseNodeIndexPermutation.push_back(match.third);
@@ -197,55 +198,16 @@ findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
}
ReferenceSpace::triplet ReferenceSpace::
-isCyclicPermutation(const vector<size_t>& pTest,
- const vector<size_t>& pRef) const{
+isSameConnectivity(const vector<size_t>& pTest,
+ const vector<size_t>& pRef) const{
// Triplet to return
triplet tri;
- // If no Face, we have no Cyclic Permutation
- if(!refFaceNodeIdx.size()){
- tri.first = false;
- tri.second = vector<size_t>(0);
- tri.third = vector<size_t>(0);
-
- return tri;
- }
-
- // Node IDs of Reference Space first Face
- const size_t nNodeInFaceZero = refFaceNodeIdx[0].size();
- vector<size_t> refNode(nNodeInFaceZero);
-
- for(size_t i = 0; i < nNodeInFaceZero; i++)
- refNode[i] = pRef[refFaceNodeIdx[0][i]];
-
- // 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)){
- tri.first = false;
- tri.second = vector<size_t>(0);
- tri.third = 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);
-
- for(size_t i = 0; i < nNodeInFaceTest; i++)
- testNode[i] = pTest[refFaceNodeIdx[testFaceId][i]];
+ // Test if we have the same connectivity (i.e. the same edges)
+ bool haveSameEdge = isSameEdge(pTest, pRef);
- // Test if we have a face cyclic permutation
- size_t isCyclic = isFacePermutation(refNode, testNode);
-
- // Test if we have the same connectivity
- bool isSameConnectivity = isSameEdge(pTest, pRef);
-
- //if(isCyclic && isSameConnectivity){
- if(isSameConnectivity){
+ if(haveSameEdge){
tri.first = true;
tri.second = getRefIndexPermutation(pRef, pTest);
tri.third = getReverseIndexPermutation(pRef, pTest);
@@ -260,95 +222,6 @@ isCyclicPermutation(const vector<size_t>& pTest,
return tri;
}
-size_t ReferenceSpace::findCorrespondingFace(const vector<size_t>& face,
- const vector<size_t>& node) const{
- // Init Stuff //
- const size_t nFace = refFaceNodeIdx.size();
- const size_t faceSize = face.size();
- bool match = false;
- size_t f = 0;
-
- vector<size_t> testFace(faceSize);
- size_t nNodeInFace;
-
- // Test All Face until match
- while(!match && f < nFace){
- nNodeInFace = refFaceNodeIdx[f].size();
-
- if(nNodeInFace == faceSize){
- // Get face f nodes
- for(size_t i = 0; i < faceSize; i++)
- testFace[i] = node[refFaceNodeIdx[f][i]];
-
- // Look if match
- match = haveSameNode(testFace, face);
- }
-
- if(!match)
- f++;
- }
-
- // If a valid face is found return it
- if(f < nFace)
- return f;
-
- // Else return (size_t)(-1)
- else
- return -1;
-}
-
-bool ReferenceSpace::haveSameNode(const vector<size_t>& face0,
- const vector<size_t>& face1){
- // Check Sizes
- const size_t size = face0.size();
-
- if(size != face1.size())
- return false;
-
- // Copy vector
- vector<size_t> cFace0(face0);
- vector<size_t> cFace1(face1);
-
- // Sort both copy vectors
- sort(cFace0.begin(), cFace0.end());
- sort(cFace1.begin(), cFace1.end());
-
- // Check if elements are the same and at same position
- bool match = true;
-
- for(size_t i = 0; i < size && match; i++)
- match = (cFace0[i] == cFace1[i]);
-
- return match;
-}
-
-bool ReferenceSpace::isFacePermutation(const vector<size_t>& refNode,
- const vector<size_t>& testNode){
- // Check Size
- const size_t size = refNode.size();
-
- if(size != testNode.size())
- return false;
-
- // Find refNode[0] in testNode
- size_t offset = 0;
-
- while(refNode[0] != testNode[offset] && offset < size)
- offset++;
-
- // If refNode[0] not found in testNode, there is no face permutation
- if(offset == size)
- return false;
-
- // Check refNode[i] and testNode[(i + offset) % size]
- bool match = true;
-
- for(size_t i = 0; i < size && match; i++)
- match = (refNode[i] == testNode[(i + offset) % size]);
-
- return match;
-}
-
bool ReferenceSpace::isSameEdge(const std::vector<size_t>& pTest,
const std::vector<size_t>& pRef) const{
// Set of Reference Edges
diff --git a/FunctionSpace/ReferenceSpace.h b/FunctionSpace/ReferenceSpace.h
index 07f9b8afa0..1e0e04489e 100644
--- a/FunctionSpace/ReferenceSpace.h
+++ b/FunctionSpace/ReferenceSpace.h
@@ -150,22 +150,13 @@ class ReferenceSpace{
void getOrderedEdge(void);
void getOrderedFace(void);
- void findCyclicPermutation
+ void findConnectivity
(std::list<size_t>& listOfTrueReferenceSpace,
std::list<std::vector<size_t> >& listOfRefNodeIndexPermutation,
std::list<std::vector<size_t> >& listOfReverseNodeIndexPermutation);
- triplet isCyclicPermutation(const std::vector<size_t>& pTest,
- const std::vector<size_t>& pRef) const;
-
- size_t findCorrespondingFace(const std::vector<size_t>& face,
- const std::vector<size_t>& node) const;
-
- static bool haveSameNode(const std::vector<size_t>& face0,
- const std::vector<size_t>& face1);
-
- static bool isFacePermutation(const std::vector<size_t>& refNode,
- const std::vector<size_t>& testNode);
+ triplet isSameConnectivity(const std::vector<size_t>& pTest,
+ const std::vector<size_t>& pRef) const;
bool isSameEdge(const std::vector<size_t>& pTest,
const std::vector<size_t>& pRef) const;
diff --git a/FunctionSpace/TriReferenceSpace.cpp b/FunctionSpace/TriReferenceSpace.cpp
index 449502e939..69ecc2c04b 100644
--- a/FunctionSpace/TriReferenceSpace.cpp
+++ b/FunctionSpace/TriReferenceSpace.cpp
@@ -6,21 +6,6 @@
using namespace std;
TriReferenceSpace::TriReferenceSpace(void){
- // Look if a serialized TriReferenceSpace is present in root //
- // If it does, load it //
- // If not, create it and serialize it for an other time //
-
- try{
- init(string("tri.refSpace"));
- }
-
- catch(std::exception& exception){
- initTri();
- serialize("tri.refSpace");
- }
-}
-
-void TriReferenceSpace::initTri(void){
// Vertex Definition //
nVertex = 3;
diff --git a/FunctionSpace/TriReferenceSpace.h b/FunctionSpace/TriReferenceSpace.h
index 86dafed656..9f52b5d64e 100644
--- a/FunctionSpace/TriReferenceSpace.h
+++ b/FunctionSpace/TriReferenceSpace.h
@@ -17,9 +17,6 @@ class TriReferenceSpace: public ReferenceSpace{
virtual ~TriReferenceSpace(void);
virtual std::string toLatex(void) const;
-
- private:
- void initTri(void);
};
/**
--
GitLab