diff --git a/FunctionSpace/PermutationTree.cpp b/FunctionSpace/PermutationTree.cpp
index d9b916adbfc6935b5cde7805e9e3d6ae5367e6a6..1713e49ddee8d307baea7eed9892da04e001ad9f 100644
--- a/FunctionSpace/PermutationTree.cpp
+++ b/FunctionSpace/PermutationTree.cpp
@@ -8,7 +8,7 @@
using namespace std;
-PermutationTree::PermutationTree(const vector<size_t>& refSequence){
+PermutationTree::PermutationTree(const std::vector<size_t>& refSequence){
// Sequence size //
sequenceSize = refSequence.size();
@@ -42,7 +42,7 @@ PermutationTree::PermutationTree(const char* stream){
populateFromStream(stream);
}
-PermutationTree::PermutationTree(const string& path){
+PermutationTree::PermutationTree(const std::string& path){
// Read file //
// Open Stream
ifstream input;
@@ -68,7 +68,7 @@ PermutationTree::PermutationTree(const string& path){
}
void PermutationTree::populate(node_t* node,
- list<node_t*>& listOfLeaf){
+ std::list<node_t*>& listOfLeaf){
// Node Id //
node->nodeId = nextNodeId;
nextNodeId++;
@@ -176,7 +176,7 @@ void PermutationTree::unserialize(const char* stream, unlink_t* unlink){
stream + otherIdStart + 2 * sizeof(size_t), sizeof(size_t));
}
-void PermutationTree::rebuild(vector<unlink_t>& unlink){
+void PermutationTree::rebuild(std::vector<unlink_t>& unlink){
// Almost linked nodes (node of node_t type but without connected nodes) //
vector<node_t*> node(nextNodeId);
for(size_t i = 0; i < nextNodeId; i++)
@@ -237,7 +237,7 @@ void PermutationTree::destroy(node_t* node){
PermutationTree::node_t*
PermutationTree::getLeaf(node_t* root,
- const vector<size_t>& sequence,
+ const std::vector<size_t>& sequence,
size_t offset){
// Number of son
const size_t nSon = root->son.size();
@@ -262,8 +262,9 @@ PermutationTree::getLeaf(node_t* root,
}
}
-void PermutationTree::fillWithPermutation(size_t permutationId,
- vector<size_t>& vectorToFill) const{
+void
+PermutationTree::fillWithPermutation(size_t permutationId,
+ std::vector<size_t>& vectorToFill) const{
// Go from ith leaf to root //
// And fill vectorToFill from end to start //
@@ -400,7 +401,7 @@ std::pair<size_t, char*> PermutationTree::serialize(void) const{
return pair<size_t, char*>(sSize, stream);
}
-void PermutationTree::serialize(const string& path) const{
+void PermutationTree::serialize(const std::string& path) const{
// Serialize into byte Stream
std::pair<size_t, char*> stream = serialize();
diff --git a/FunctionSpace/PermutationTree.h b/FunctionSpace/PermutationTree.h
index ce19b5b1e9e6d52dd8c56065686ffcfd619b4871..364519623c159bd6f1dadaeea5b9f3cbee68896d 100644
--- a/FunctionSpace/PermutationTree.h
+++ b/FunctionSpace/PermutationTree.h
@@ -123,7 +123,7 @@ class PermutationTree{
@see PermutationTree:serialize(char*)
**
- @fn PermutationTree::PermutationTree(std::string path)
+ @fn PermutationTree::PermutationTree(const std::string& path)
@param path A file path
Instanciates a new PermutationTree by loading the file given in path
@@ -195,7 +195,7 @@ class PermutationTree{
@return Returns a string describing this PermutationTree
**
- @fn PermutationTree::serialize(void)
+ @fn PermutationTree::serialize(void) const
Serialize this PermutationTree into a byte stream
@@ -204,7 +204,7 @@ class PermutationTree{
@li the second entry is a pointer to the allocated stream
**
- @fn PermutationTree::serialize(const std::string&)
+ @fn PermutationTree::serialize(const std::string&) const
@param path A file path
Serialize this PermutationTree into the given file path
diff --git a/FunctionSpace/ReferenceSpace.cpp b/FunctionSpace/ReferenceSpace.cpp
index 7af6d330d24490cad4cd93dedb1224173cd553e5..1eeb3dec43983e65c2aebebef639742911aa6840 100644
--- a/FunctionSpace/ReferenceSpace.cpp
+++ b/FunctionSpace/ReferenceSpace.cpp
@@ -1,5 +1,7 @@
#include <algorithm>
+#include <fstream>
#include <sstream>
+#include <cstring>
#include <set>
#include "Exception.h"
@@ -13,6 +15,31 @@ ReferenceSpace::ReferenceSpace(void){
// Derived Class //
}
+ReferenceSpace::ReferenceSpace(const std::string& path){
+ // Read file //
+ // Open Stream
+ ifstream input;
+ input.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+ input.open(path.c_str(), std::ifstream::binary);
+
+ // Get size of stream (go to stream end)
+ input.seekg(0, std::ifstream::end);
+ const size_t size = input.tellg();
+
+ // Reset stream possition
+ input.seekg(0, std::ifstream::beg);
+
+ // Alloc byte stream & Read file
+ char* stream = new char[size];
+ input.read(stream, size);
+
+ // Init from stream
+ init(stream);
+
+ // Free stream
+ delete[] stream;
+}
+
ReferenceSpace::~ReferenceSpace(void){
delete pTree;
}
@@ -68,6 +95,40 @@ void ReferenceSpace::init(void){
getOrderedFace();
}
+void ReferenceSpace::init(const char* stream){
+ // nVector
+ size_t offset = 0;
+
+ memcpy(&nVertex, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Fef {Edge, Face} Node Idx
+ offset += unserialize(stream + offset, refEdgeNodeIdx);
+ offset += unserialize(stream + offset, refFaceNodeIdx);
+
+ // Permutation Tree
+ size_t tSize; // Tree Size
+
+ memcpy(&tSize, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ pTree = new PermutationTree(stream + offset);
+ offset += tSize;
+
+ // RefSpace Node Id
+ offset += unserialize(stream + offset, refSpaceNodeId);
+
+ // Index mapping
+ offset += unserialize(stream + offset, ABCtoUVWIndex);
+ offset += unserialize(stream + offset, UVWtoABCIndex);
+
+ // Oredered {Edge, Face} Node Idx
+ offset += unserialize(stream + offset, orderedEdgeNodeIdx);
+ offset += unserialize(stream + offset, orderedFaceNodeIdx);
+
+ cout << offset << endl;
+}
+
void ReferenceSpace::
findCyclicPermutation(list<size_t>& listOfTrueReferenceSpace,
list<vector<size_t> >& listOfRefNodeIndexPermutation,
@@ -844,3 +905,277 @@ string ReferenceSpace::toLatex(void) const{
return stream.str();
}
+
+std::pair<size_t, char*> ReferenceSpace::serialize(void) const{
+ // Serialize //
+ // refEdgeNodeIdx
+ pair<size_t, char*> sRefEdgeIdx = serialize(refEdgeNodeIdx);
+
+ // refFaceNodeIdx
+ pair<size_t, char*> sRefFaceIdx = serialize(refFaceNodeIdx);
+
+ // PermutationTree
+ pair<size_t, char*> sPTree = pTree->serialize();
+
+ // Reference Space
+ pair<size_t, char*> sRSpace = serialize(refSpaceNodeId);
+
+ // ABCtoUVW
+ pair<size_t, char*> sABCtoUVW = serialize(ABCtoUVWIndex);
+
+ // UVWtoUVW
+ pair<size_t, char*> sUVWtoABC = serialize(UVWtoABCIndex);
+
+ // orderedEdgeNodeIdx
+ pair<size_t, char*> sEdgeIdx = serialize(orderedEdgeNodeIdx);
+
+ // orderedEdgeNodeIdx
+ pair<size_t, char*> sFaceIdx = serialize(orderedFaceNodeIdx);
+
+ // Full Serialized Stream //
+ // Alloc (+ 1 * sizeof(size_t) for nVertex)
+ const size_t size = sizeof(size_t) + sRefEdgeIdx.first
+ + sRefFaceIdx.first
+ + sizeof(size_t) // pTree Size
+ + sPTree.first // pTree
+ + sRSpace.first
+ + sABCtoUVW.first
+ + sUVWtoABC.first
+ + sEdgeIdx.first
+ + sFaceIdx.first;
+ char* stream = new char[size];
+
+ // Populate
+ size_t offset = 0;
+
+ memcpy(stream + offset, &nVertex, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ memcpy(stream + offset, sRefEdgeIdx.second, sRefEdgeIdx.first);
+ offset += sRefEdgeIdx.first;
+
+ memcpy(stream + offset, sRefFaceIdx.second, sRefFaceIdx.first);
+ offset += sRefFaceIdx.first;
+
+ memcpy(stream + offset, &sPTree.first, sizeof(size_t)); // pTree size
+ offset += sizeof(size_t);
+
+ memcpy(stream + offset, sPTree.second, sPTree.first); // pTree
+ offset += sPTree.first;
+
+ memcpy(stream + offset, sRSpace.second, sRSpace.first);
+ offset += sRSpace.first;
+
+ memcpy(stream + offset, sABCtoUVW.second, sABCtoUVW.first);
+ offset += sABCtoUVW.first;
+
+ memcpy(stream + offset, sUVWtoABC.second, sABCtoUVW.first);
+ offset += sABCtoUVW.first;
+
+ memcpy(stream + offset, sEdgeIdx.second, sEdgeIdx.first);
+ offset += sEdgeIdx.first;
+
+ memcpy(stream + offset, sFaceIdx.second, sFaceIdx.first);
+ offset += sFaceIdx.first;
+
+ // Free Temp
+ delete[] sRefEdgeIdx.second;
+ delete[] sRefFaceIdx.second;
+ delete[] sPTree.second;
+ delete[] sRSpace.second;
+ delete[] sABCtoUVW.second;
+ delete[] sUVWtoABC.second;
+ delete[] sEdgeIdx.second;
+ delete[] sFaceIdx.second;
+
+ // Return
+ return pair<size_t, char*>(size, stream);
+}
+
+void ReferenceSpace::serialize(const std::string& path) const{
+ // Serialize into byte Stream
+ std::pair<size_t, char*> stream = serialize();
+
+ // Write byte stream
+ ofstream output;
+ output.exceptions(std::ofstream::failbit | std::ofstream::badbit);
+ output.open(path.c_str(), std::ofstream::binary);
+ output.write(stream.second, stream.first);
+ output.close();
+
+ // Free
+ delete[] stream.second;
+}
+
+std::pair<size_t, char*> ReferenceSpace::
+serialize(const std::vector<std::vector<size_t> >& source){
+ // Vector & Stream size //
+ size_t nVector = source.size();
+ size_t totalSize = sizeof(size_t); // Init to header size (nVector)
+
+ for(size_t i = 0; i < nVector; i++)
+ totalSize += (source[i].size() + 1) * sizeof(size_t);
+ // + 1 for subvector size header
+
+ // Alloc Stream //
+ char* stream = new char[totalSize];
+
+ // Header (nVector) //
+ memcpy(stream, &nVector, sizeof(size_t));
+
+ // SubVectors //
+ size_t tmpSize;
+ size_t offset = sizeof(size_t);
+
+ for(size_t i = 0; i < nVector; i++){
+ // SubVector size
+ tmpSize = source[i].size();
+ memcpy(stream + offset, &tmpSize, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // SubVector stored values
+ for(size_t j = 0; j < tmpSize; j++){
+ memcpy(stream + offset, &source[i][j], sizeof(size_t));
+ offset += sizeof(size_t);
+ }
+ }
+
+ // Return //
+ return pair<size_t, char*>(totalSize, stream);
+}
+
+std::pair<size_t, char*> ReferenceSpace::
+serialize(const std::vector<std::vector<std::vector<size_t> > >& source){
+ // Vector & Stream size //
+ size_t nVector = source.size();
+ size_t totalSize = sizeof(size_t); // Init to header size (nVector)
+
+ for(size_t i = 0; i < nVector; i++){
+ totalSize += sizeof(size_t); // Subvector size header
+
+ for(size_t j = 0; j < source[i].size(); j++)
+ totalSize += (source[i][j].size() + 1) * sizeof(size_t);
+ // + 1 for subsubvector size header
+ }
+
+ // Alloc Stream //
+ char* stream = new char[totalSize];
+
+ // Header (nVector) //
+ memcpy(stream, &nVector, sizeof(size_t));
+
+ // SubVectors //
+ size_t tmpSize;
+ size_t tmpSubSize;
+ size_t offset = sizeof(size_t);
+
+ for(size_t i = 0; i < nVector; i++){
+ // SubVector size
+ tmpSize = source[i].size();
+ memcpy(stream + offset, &tmpSize, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ for(size_t j = 0; j < tmpSize; j++){
+ // SubSubVector size
+ tmpSubSize = source[i][j].size();
+ memcpy(stream + offset, &tmpSubSize, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // SubSubVector stored values
+ for(size_t k = 0; k < tmpSubSize; k++){
+ memcpy(stream + offset, &source[i][j][k], sizeof(size_t));
+ offset += sizeof(size_t);
+ }
+ }
+ }
+
+ // Return //
+ return pair<size_t, char*>(totalSize, stream);
+}
+
+size_t ReferenceSpace::
+unserialize(const char* stream,
+ std::vector<std::vector<size_t> >& dest){
+ // Vector size //
+ size_t nVector;
+ size_t offset = 0;
+
+ memcpy(&nVector, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Alloc Vector //
+ dest.resize(nVector);
+
+ // Populate //
+ size_t tmpSize;
+ size_t tmpVal;
+
+ for(size_t i = 0; i < nVector; i++){
+ // Subvector size
+ memcpy(&tmpSize, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Alloc Subvector
+ dest[i].resize(tmpSize);
+
+ // Populate Subvector
+ for(size_t j = 0; j < tmpSize; j++){
+ memcpy(&tmpVal, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ dest[i][j] = tmpVal;
+ }
+ }
+
+ // Return size //
+ return offset;
+}
+
+size_t ReferenceSpace::
+ unserialize(const char* stream,
+ std::vector<std::vector<std::vector<size_t> > >& dest){
+ // Vector size //
+ size_t nVector;
+ size_t offset = 0;
+
+ memcpy(&nVector, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Alloc Vector //
+ dest.resize(nVector);
+
+ // Populate //
+ size_t tmpSize;
+ size_t tmpSubSize;
+ size_t tmpVal;
+
+ for(size_t i = 0; i < nVector; i++){
+ // Subvector size
+ memcpy(&tmpSize, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Alloc Subvector
+ dest[i].resize(tmpSize);
+
+ // Populate Subvector
+ for(size_t j = 0; j < tmpSize; j++){
+ // Subsubvector size
+ memcpy(&tmpSubSize, stream + offset, sizeof(size_t));
+ offset += sizeof(size_t);
+
+ // Alloc Subsubvector
+ dest[i][j].resize(tmpSubSize);
+
+ // Populate Subsubvector
+ for(size_t k = 0; k < tmpSubSize; k++){
+ memcpy(&tmpVal, stream + offset,sizeof(size_t));
+ offset += sizeof(size_t);
+
+ dest[i][j][k] = tmpVal; // AT LAST !! (-:
+ }
+ }
+ }
+
+ // Return size //
+ return offset;
+}
diff --git a/FunctionSpace/ReferenceSpace.h b/FunctionSpace/ReferenceSpace.h
index ebaa7becccf11ff111881b327e183701a2fce415..68c26a3717b9b974afb52450b3ba1ba8b3354dee 100644
--- a/FunctionSpace/ReferenceSpace.h
+++ b/FunctionSpace/ReferenceSpace.h
@@ -16,6 +16,8 @@
This class represents the notion of Reference Space.
A Reference Space is the set of all the permutations
of the reference element of a particular geometrical entity.
+
+ @todo End ReferenceSpace DOC !!!
*/
class ReferenceSpace{
@@ -56,6 +58,7 @@ class ReferenceSpace{
std::vector<std::vector<std::vector<size_t> > > orderedFaceNodeIdx;
public:
+ ReferenceSpace(const std::string& path);
virtual ~ReferenceSpace(void);
size_t getNReferenceSpace(void) const;
@@ -93,10 +96,14 @@ class ReferenceSpace{
virtual std::string toString(void) const;
virtual std::string toLatex(void) const;
+ std::pair<size_t, char*> serialize(void) const;
+ void serialize(const std::string& path) const;
+
protected:
ReferenceSpace(void);
void init(void);
+ void init(const char* stream);
private:
void getOrderedEdge(void);
@@ -147,16 +154,36 @@ class ReferenceSpace{
const std::pair<size_t, size_t>& b);
static void regularize(size_t dim, fullMatrix<double>& jac);
+
+ static std::pair<size_t, char*>
+ serialize(const std::vector<std::vector<size_t> >& source);
+
+ static std::pair<size_t, char*>
+ serialize(const std::vector<std::vector<std::vector<size_t> > >& source);
+
+ static size_t
+ unserialize(const char* stream,
+ std::vector<std::vector<size_t> >& dest);
+
+ static size_t
+ unserialize(const char* stream,
+ std::vector<std::vector<std::vector<size_t> > >& dest);
};
/**
@internal
- @fn ReferenceSpace::ReferenceSpace
+ @fn ReferenceSpace::ReferenceSpace(void)
Instatiate a new ReferenceSpace
@endinternal
**
+ @fn ReferenceSpace::ReferenceSpace(const std::string&)
+ @param path A file path
+
+ Instanciates a new ReferenceSpace by loading the file in the given path
+ **
+
@fn ReferenceSpace::~ReferenceSpace
Deletes this ReferenceSpace
**
@@ -201,6 +228,22 @@ class ReferenceSpace{
@fn ReferenceSpace::toLatex
@return Returns a string (of a Latex file) describing this ReferenceSpace
+ **
+
+ @fn ReferenceSpace::serialize(void) const
+
+ Serialize this ReferenceSpace into a byte stream
+
+ @return Returns a pair such that:
+ @li The first entry is the byte stream size
+ @li The second entry is a pointer the allocated byte stream
+ **
+
+ @fn ReferenceSpace::serialize(const std::string&) const
+ @param path A file path
+
+ Serialize this ReferenceSpace into the given file
+ **
*/
//////////////////////