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

Reworking Lagrange stuff -- Adding HexLagrangeBasis

parent 99c830a0
No related branches found
No related tags found
No related merge requests found
Showing
with 80 additions and 400 deletions
...@@ -24,7 +24,7 @@ ...@@ -24,7 +24,7 @@
#include "HexNodeBasis.h" #include "HexNodeBasis.h"
#include "HexEdgeBasis.h" #include "HexEdgeBasis.h"
#include "HexLagrangeBasis.h"
BasisGenerator::BasisGenerator(void){ BasisGenerator::BasisGenerator(void){
} }
...@@ -75,7 +75,7 @@ BasisLocal* BasisGenerator::generateLagrange(size_t elementType, ...@@ -75,7 +75,7 @@ BasisLocal* BasisGenerator::generateLagrange(size_t elementType,
case TYPE_TRI: return new TriLagrangeBasis(order); case TYPE_TRI: return new TriLagrangeBasis(order);
case TYPE_QUA: return new QuadLagrangeBasis(order); case TYPE_QUA: return new QuadLagrangeBasis(order);
case TYPE_TET: return new TetLagrangeBasis(order); case TYPE_TET: return new TetLagrangeBasis(order);
case TYPE_HEX: throw Exception("Lagrange Basis on Hexs not Implemented"); case TYPE_HEX: return new HexLagrangeBasis(order);
default: throw Exception("Unknown Element Type (%d) for Basis Generation", default: throw Exception("Unknown Element Type (%d) for Basis Generation",
elementType); elementType);
......
...@@ -16,9 +16,6 @@ set(SRC ...@@ -16,9 +16,6 @@ set(SRC
TetReferenceSpace.cpp TetReferenceSpace.cpp
HexReferenceSpace.cpp HexReferenceSpace.cpp
ReferenceSpaceLagrange.cpp
TriLagrangeReferenceSpace.cpp
Basis.cpp Basis.cpp
BasisLocal.cpp BasisLocal.cpp
BasisGenerator.cpp BasisGenerator.cpp
...@@ -49,6 +46,7 @@ set(SRC ...@@ -49,6 +46,7 @@ set(SRC
HexNodeBasis.cpp HexNodeBasis.cpp
HexEdgeBasis.cpp HexEdgeBasis.cpp
HexLagrangeBasis.cpp
FunctionSpace.cpp FunctionSpace.cpp
FunctionSpaceScalar.cpp FunctionSpaceScalar.cpp
......
#include "HexLagrangeBasis.h"
#include "pointsGenerators.h"
#include "ElementType.h"
HexLagrangeBasis::HexLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1
if(order == 0)
order = 1;
// Set Basis Type //
this->order = order;
type = 0;
dim = 3;
nVertex = 8;
nEdge = 12 * (order - 1);
nFace = 6 * (order - 1) * (order - 1);
nCell = (order - 1) * (order - 1) * (order - 1);
nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis //
lBasis = new polynomialBasis(ElementType::getTag(TYPE_HEX, order, false));
// Init Lagrange Point //
lPoint = new fullMatrix<double>(gmshGeneratePointsHexahedron(order, false));
}
HexLagrangeBasis::~HexLagrangeBasis(void){
delete lBasis;
delete lPoint;
}
#ifndef _HEXLAGRANGEBASIS_H_
#define _HEXLAGRANGEBASIS_H_
#include "BasisLagrange.h"
/**
@class HexLagrangeBasis
@brief Lagrange Basis for Hexahedra
This class can instantiate a @em Lagrange @em Basis
for a Hexahedron and for a given Order.@n
It uses
<a href="http://geuz.org/gmsh/">gmsh</a> Basis.
*/
class HexLagrangeBasis: public BasisLagrange{
public:
//! @param order A natural number
//!
//! Returns a new HexLagrangeBasis
//! of the given Order
HexLagrangeBasis(size_t order);
//! Deletes this Basis
//!
virtual ~HexLagrangeBasis(void);
};
#endif
#include "Exception.h"
#include "LineLagrangeBasis.h" #include "LineLagrangeBasis.h"
#include "pointsGenerators.h" #include "pointsGenerators.h"
#include "ElementType.h" #include "ElementType.h"
LineLagrangeBasis::LineLagrangeBasis(unsigned int order){ LineLagrangeBasis::LineLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1 // If order 0 (Nedelec): use order 1
if(order == 0) if(order == 0)
order = 1; order = 1;
...@@ -21,26 +20,13 @@ LineLagrangeBasis::LineLagrangeBasis(unsigned int order){ ...@@ -21,26 +20,13 @@ LineLagrangeBasis::LineLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell; nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis // // Init polynomialBasis //
lBasis = new polynomialBasis(getTag(order)); lBasis = new polynomialBasis(ElementType::getTag(TYPE_LIN, order, false));
// Init Lagrange Point // // Init Lagrange Point //
lPoint = new fullMatrix<double> lPoint = new fullMatrix<double>(gmshGeneratePointsLine(order));
(gmshGeneratePointsLine(order));
} }
LineLagrangeBasis::~LineLagrangeBasis(void){ LineLagrangeBasis::~LineLagrangeBasis(void){
delete lBasis; delete lBasis;
delete lPoint; delete lPoint;
} }
unsigned int LineLagrangeBasis::getTag(unsigned int order){
unsigned int tag = ElementType::getTag(TYPE_LIN, order, false);
if(tag)
return tag;
else
throw Exception
("Can't instanciate an order %d Lagrangian Basis for a Line",
order);
}
...@@ -20,17 +20,11 @@ class LineLagrangeBasis: public BasisLagrange{ ...@@ -20,17 +20,11 @@ class LineLagrangeBasis: public BasisLagrange{
//! //!
//! Returns a new LineLagrangeBasis //! Returns a new LineLagrangeBasis
//! of the given Order //! of the given Order
LineLagrangeBasis(unsigned int order); LineLagrangeBasis(size_t order);
//! Deletes this Basis //! Deletes this Basis
//! //!
virtual ~LineLagrangeBasis(void); virtual ~LineLagrangeBasis(void);
private:
//! @param order A natural number
//! @return Returns the @em tag of a @em Line of
//! the given order
static unsigned int getTag(unsigned int order);
}; };
#endif #endif
#include "Exception.h"
#include "QuadLagrangeBasis.h" #include "QuadLagrangeBasis.h"
#include "pointsGenerators.h" #include "pointsGenerators.h"
#include "ElementType.h" #include "ElementType.h"
QuadLagrangeBasis::QuadLagrangeBasis(unsigned int order){ QuadLagrangeBasis::QuadLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1 // If order 0 (Nedelec): use order 1
if(order == 0) if(order == 0)
order = 1; order = 1;
...@@ -21,26 +20,13 @@ QuadLagrangeBasis::QuadLagrangeBasis(unsigned int order){ ...@@ -21,26 +20,13 @@ QuadLagrangeBasis::QuadLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell; nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis // // Init polynomialBasis //
lBasis = new polynomialBasis(getTag(order)); lBasis = new polynomialBasis(ElementType::getTag(TYPE_QUA, order, false));
// Init Lagrange Point // // Init Lagrange Point //
lPoint = new fullMatrix<double> lPoint = new fullMatrix<double>(gmshGeneratePointsQuadrangle(order, false));
(gmshGeneratePointsQuadrangle(order, false));
} }
QuadLagrangeBasis::~QuadLagrangeBasis(void){ QuadLagrangeBasis::~QuadLagrangeBasis(void){
delete lBasis; delete lBasis;
delete lPoint; delete lPoint;
} }
unsigned int QuadLagrangeBasis::getTag(unsigned int order){
unsigned int tag = ElementType::getTag(TYPE_QUA, order, false);
if(tag)
return tag;
else
throw Exception
("Can't instanciate an order %d Lagrangian Basis for a Quadrangle",
order);
}
...@@ -20,17 +20,11 @@ class QuadLagrangeBasis: public BasisLagrange{ ...@@ -20,17 +20,11 @@ class QuadLagrangeBasis: public BasisLagrange{
//! //!
//! Returns a new QuadLagrangeBasis //! Returns a new QuadLagrangeBasis
//! of the given Order //! of the given Order
QuadLagrangeBasis(unsigned int order); QuadLagrangeBasis(size_t order);
//! Deletes this Basis //! Deletes this Basis
//! //!
virtual ~QuadLagrangeBasis(void); virtual ~QuadLagrangeBasis(void);
private:
//! @param order A natural number
//! @return Returns the @em tag of a @em Quadrangle of
//! the given order
static unsigned int getTag(unsigned int order);
}; };
#endif #endif
#include <sstream>
#include "ReferenceSpaceLagrange.h"
using namespace std;
ReferenceSpaceLagrange::ReferenceSpaceLagrange(void){
// Init to NULL //
node = NULL;
}
ReferenceSpaceLagrange::~ReferenceSpaceLagrange(void){
const size_t nPerm = pTree->getNPermutation();
// If 'node' allocated //
if(node){
for(size_t p = 0; p < nPerm; p++)
delete (*node)[p];
delete node;
}
}
void ReferenceSpaceLagrange::getLagrangeNode(void){
/*
const size_t nPerm = pTree->getNPermutation();
// Alloc //
vector<size_t>* tmp;
node = new vector<const vector<size_t>*>(nPerm);
// Populate //
for(size_t p = 0; p < nPerm; p++){
// Alloc Temp //
tmp = new vector<size_t>(nNode);
// Vertex based node
for(size_t i = 0; i < nVertex; i++)
(*tmp)[i] = i;
// Edge based node
for(size_t e = 0; e < nEdge; e++)
edgeSeq(*tmp,
nVertex + nNodePerEdge * e,
nVertex + nNodePerEdge * e,
nVertex + nNodePerEdge * (e + 1),
refEdge[e],
*(*(*edge)[p])[e]);
// Face based node
for(size_t f = 0; f < nFace; f++)
faceSeq(*tmp,
nVertex + nNodePerEdge * nEdge + nNodePerFace * f,
nVertex + nNodePerEdge * nEdge + nNodePerFace * f,
nVertex + nNodePerEdge * nEdge + nNodePerFace * (f + 1),
refFace[f],
*(*(*face)[p])[f],
nNodePerEdge);
// Insert in node
(*node)[p] = tmp;
}
*/
}
void ReferenceSpaceLagrange::edgeSeq(vector<size_t>& vec,
size_t startIdx,
size_t startVal,
size_t stopVal,
size_t* refEdge,
const vector<size_t>& edge){
// Is reverted ? //
const bool isRevert = (edge[0] != refEdge[0]);
// Index //
size_t val = startVal;
size_t idx;
// Depending if edge is reverted ...
if(isRevert)
idx = startIdx + stopVal - startVal - 1;
else
idx = startIdx;
// Populate //
for(; val < stopVal; val++){
vec[idx] = val;
if(isRevert)
idx--;
else
idx++;
}
}
void ReferenceSpaceLagrange::faceSeq(vector<size_t>& vec,
size_t startIdx,
size_t startVal,
size_t stopVal,
size_t* refFace,
const vector<size_t>& face,
size_t nNodePerEdge){
// Index //
size_t val = startVal;
size_t idx = startIdx;
// Populate //
for(; val < stopVal; val++){
vec[idx] = val;
idx++;
}
}
string ReferenceSpaceLagrange::toString(void) const{
const size_t nPerm = pTree->getNPermutation();
const size_t nNodeMinus = nNode - 1;
stringstream stream;
stream << ReferenceSpace::toString();
stream << "Lagrange Nodes Permutations:" << endl;
for(size_t i = 0; i < nPerm; i++){
stream << " * RefSpace #" << i + 1 << ":" << endl
<< " -- [";
for(size_t j = 0; j < nNodeMinus; j++)
stream << node->at(i)->at(j) << ", ";
stream << node->at(i)->at(nNodeMinus) << "]" << endl;
}
return stream.str();
}
#ifndef _REFERENCESPACELAGRANGE_H_
#define _REFERENCESPACELAGRANGE_H_
#include "ReferenceSpace.h"
/**
@interface ReferenceSpaceLagrange
@brief Base interface for all Lagrange ReferenceSpace%s
This class is a particular ReferenceSpace for
@em Lagrange Basis.@n
This class adds the notion of Lagrange points and
their permutations depending on the orientation
of a MElement.@n
Lagrange points are ordered in a way such that
Lagrange function must be taken in that order in order
to have an oriented basis.@n
Because the number of Lagrange Points depends on
the the order of the Lagrange Basis,
a ReferenceSpaceLagrange shall depend on the order.
*/
class ReferenceSpaceLagrange: public ReferenceSpace{
protected:
// Lagrange Node Permutation //
size_t nNode;
size_t nNodePerEdge;
size_t nNodePerFace;
size_t nNodePerCell;
std::vector<const std::vector<size_t>*>* node;
public:
virtual ~ReferenceSpaceLagrange(void);
const std::vector<const std::vector<size_t>*>&
getAllLagrangeNode(void) const;
virtual std::string toString(void) const;
protected:
ReferenceSpaceLagrange(void);
void getLagrangeNode(void);
static void edgeSeq(std::vector<size_t>& vec,
size_t startIdx,
size_t startVal,
size_t stopVal,
size_t* refEdge,
const std::vector<size_t>& edge);
static void faceSeq(std::vector<size_t>& vec,
size_t startIdx,
size_t startVal,
size_t stopVal,
size_t* refFace,
const std::vector<size_t>& face,
size_t nNodePerEdge);
};
/////////////////////
// Inline Function //
/////////////////////
inline
const std::vector<const std::vector<size_t>*>&
ReferenceSpaceLagrange::getAllLagrangeNode(void) const{
return *node;
}
#endif
#include "Exception.h"
#include "TetLagrangeBasis.h" #include "TetLagrangeBasis.h"
#include "pointsGenerators.h" #include "pointsGenerators.h"
#include "ElementType.h" #include "ElementType.h"
TetLagrangeBasis::TetLagrangeBasis(unsigned int order){ TetLagrangeBasis::TetLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1 // If order 0 (Nedelec): use order 1
if(order == 0) if(order == 0)
order = 1; order = 1;
...@@ -21,26 +20,13 @@ TetLagrangeBasis::TetLagrangeBasis(unsigned int order){ ...@@ -21,26 +20,13 @@ TetLagrangeBasis::TetLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell; nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis // // Init polynomialBasis //
lBasis = new polynomialBasis(getTag(order)); lBasis = new polynomialBasis(ElementType::getTag(TYPE_TET, order, false));
// Init Lagrange Point // // Init Lagrange Point //
lPoint = new fullMatrix<double> lPoint = new fullMatrix<double>(gmshGeneratePointsTetrahedron(order, false));
(gmshGeneratePointsTetrahedron(order, false));
} }
TetLagrangeBasis::~TetLagrangeBasis(void){ TetLagrangeBasis::~TetLagrangeBasis(void){
delete lBasis; delete lBasis;
delete lPoint; delete lPoint;
} }
unsigned int TetLagrangeBasis::getTag(unsigned int order){
unsigned int tag = ElementType::getTag(TYPE_TET, order, false);
if(tag)
return tag;
else
throw Exception
("Can't instanciate an order %d Lagrangian Basis for a Tetrahedron",
order);
}
...@@ -20,17 +20,11 @@ class TetLagrangeBasis: public BasisLagrange{ ...@@ -20,17 +20,11 @@ class TetLagrangeBasis: public BasisLagrange{
//! //!
//! Returns a new TetLagrangeBasis //! Returns a new TetLagrangeBasis
//! of the given Order //! of the given Order
TetLagrangeBasis(unsigned int order); TetLagrangeBasis(size_t order);
//! Deletes this Basis //! Deletes this Basis
//! //!
virtual ~TetLagrangeBasis(void); virtual ~TetLagrangeBasis(void);
private:
//! @param order A natural number
//! @return Returns the @em tag of a @em Tetrahedron of
//! the given order
static unsigned int getTag(unsigned int order);
}; };
#endif #endif
#include "TriLagrangeBasis.h" #include "TriLagrangeBasis.h"
#include "pointsGenerators.h" #include "pointsGenerators.h"
//#include "TriReferenceSpace.h"
#include "ElementType.h" #include "ElementType.h"
TriLagrangeBasis::TriLagrangeBasis(unsigned int order){ TriLagrangeBasis::TriLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1 // If order 0 (Nedelec): use order 1
if(order == 0) if(order == 0)
order = 1; order = 1;
...@@ -24,17 +23,10 @@ TriLagrangeBasis::TriLagrangeBasis(unsigned int order){ ...@@ -24,17 +23,10 @@ TriLagrangeBasis::TriLagrangeBasis(unsigned int order){
lBasis = new polynomialBasis(ElementType::getTag(TYPE_TRI, order, false)); lBasis = new polynomialBasis(ElementType::getTag(TYPE_TRI, order, false));
// Init Lagrange Point // // Init Lagrange Point //
lPoint = new fullMatrix<double> lPoint = new fullMatrix<double>(gmshGeneratePointsTriangle(order, false));
(gmshGeneratePointsTriangle(order, false));
// ReferenceSpace //
// refSpace = new TriReferenceSpace;
// refSpace = new TriLagrangeReferenceSpace(order);
// std::cout << refSpace->toString() << std::endl;
} }
TriLagrangeBasis::~TriLagrangeBasis(void){ TriLagrangeBasis::~TriLagrangeBasis(void){
delete lBasis; delete lBasis;
delete lPoint; delete lPoint;
// delete refSpace;
} }
...@@ -20,17 +20,11 @@ class TriLagrangeBasis: public BasisLagrange{ ...@@ -20,17 +20,11 @@ class TriLagrangeBasis: public BasisLagrange{
//! //!
//! Returns a new TriLagrangeBasis //! Returns a new TriLagrangeBasis
//! of the given Order //! of the given Order
TriLagrangeBasis(unsigned int order); TriLagrangeBasis(size_t order);
//! Deletes this Basis //! Deletes this Basis
//! //!
virtual ~TriLagrangeBasis(void); virtual ~TriLagrangeBasis(void);
private:
//! @param order A natural number
//! @return Returns the @em tag of a @em Triangle of
//! the given order
static unsigned int getTag(unsigned int order);
}; };
#endif #endif
#include "TriLagrangeReferenceSpace.h"
#include "MTriangle.h"
using namespace std;
TriLagrangeReferenceSpace::TriLagrangeReferenceSpace(unsigned int order){
/*
// Vertex Definition //
nVertex = 3;
// Edge Definition //
nEdge = 3;
refEdge = new size_t*[nEdge];
for(size_t i = 0; i < nEdge; i++){
refEdge[i] = new size_t[2];
refEdge[i][0] = MTriangle::edges_tri(i, 0);
refEdge[i][1] = MTriangle::edges_tri(i, 1);
}
// Face Definition //
nFace = 1;
refFace = new size_t*[nFace];
refFace[0] = new size_t[3];
refFace[0][0] = 0;
refFace[0][1] = 1;
refFace[0][2] = 2;
// Init ReferenceSpace //
init();
// Get Lagrange Node //
nNodePerEdge = 3 * (order - 1) / nEdge;
nNodePerFace = (order - 1) * (order - 2) / 2 / nFace;
nNodePerCell = 0;
nNode =
nVertex +
nNodePerEdge * nEdge +
nNodePerFace * nFace +
nNodePerCell;
getLagrangeNode();
*/
}
TriLagrangeReferenceSpace::~TriLagrangeReferenceSpace(void){
/*
// Delete Ref Edge //
for(size_t i = 0; i < nEdge; i++)
delete[] refEdge[i];
delete[] refEdge;
// Delete Ref Face //
for(size_t i = 0; i < nFace; i++)
delete[] refFace[i];
delete[] refFace;
*/
}
#ifndef _TRILAGRANGEREFERENCESPACE_H_
#define _TRILAGRANGEREFERENCESPACE_H_
#include "ReferenceSpaceLagrange.h"
/**
@class TriLagrangeReferenceSpace
@brief ReferenceSpaceLagrange for a Triangle
This class implements a ReferenceSpaceLagrange
for a Triangle.
*/
class TriLagrangeReferenceSpace: public ReferenceSpaceLagrange{
public:
TriLagrangeReferenceSpace(unsigned int order);
virtual ~TriLagrangeReferenceSpace(void);
};
/**
@fn TriLagrangeReferenceSpace::TriLagrangeReferenceSpace
@param order A natural number
Instatiate a new ReferenceLagrangeSpace for a Triangle
of the given order
**
@fn TriReferenceLagrangeSpace::~TriReferenceLagrangeSpace
Deletes this TriReferenceSpace
*/
#endif
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment