diff --git a/FunctionSpace/BasisGenerator.cpp b/FunctionSpace/BasisGenerator.cpp
index d73e2e07e457eb815bc5f571579407579105239f..c1a12f40f96d3268ee7fbd6a9704d9605a5d65da 100644
--- a/FunctionSpace/BasisGenerator.cpp
+++ b/FunctionSpace/BasisGenerator.cpp
@@ -24,7 +24,7 @@
#include "HexNodeBasis.h"
#include "HexEdgeBasis.h"
-
+#include "HexLagrangeBasis.h"
BasisGenerator::BasisGenerator(void){
}
@@ -75,7 +75,7 @@ BasisLocal* BasisGenerator::generateLagrange(size_t elementType,
case TYPE_TRI: return new TriLagrangeBasis(order);
case TYPE_QUA: return new QuadLagrangeBasis(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",
elementType);
diff --git a/FunctionSpace/CMakeLists.txt b/FunctionSpace/CMakeLists.txt
index 724e30c5ce17c4ede7b338f26005e8811178095c..9e0a0206e6baa35b3e9beea1b9b82349d209e55a 100644
--- a/FunctionSpace/CMakeLists.txt
+++ b/FunctionSpace/CMakeLists.txt
@@ -16,9 +16,6 @@ set(SRC
TetReferenceSpace.cpp
HexReferenceSpace.cpp
- ReferenceSpaceLagrange.cpp
- TriLagrangeReferenceSpace.cpp
-
Basis.cpp
BasisLocal.cpp
BasisGenerator.cpp
@@ -49,6 +46,7 @@ set(SRC
HexNodeBasis.cpp
HexEdgeBasis.cpp
+ HexLagrangeBasis.cpp
FunctionSpace.cpp
FunctionSpaceScalar.cpp
diff --git a/FunctionSpace/HexLagrangeBasis.cpp b/FunctionSpace/HexLagrangeBasis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29c23a9330bc21d40d952bb3e7b3011a6c175890
--- /dev/null
+++ b/FunctionSpace/HexLagrangeBasis.cpp
@@ -0,0 +1,32 @@
+#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;
+}
diff --git a/FunctionSpace/HexLagrangeBasis.h b/FunctionSpace/HexLagrangeBasis.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4cd73cf2586c0942217e8fc3362fd1c496c347e
--- /dev/null
+++ b/FunctionSpace/HexLagrangeBasis.h
@@ -0,0 +1,30 @@
+#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
diff --git a/FunctionSpace/LineLagrangeBasis.cpp b/FunctionSpace/LineLagrangeBasis.cpp
index 5eab5408d0017a3f1d9089843038eaede93f29a6..9a17e5034923e447bc7db9bc287c448c45971c0b 100644
--- a/FunctionSpace/LineLagrangeBasis.cpp
+++ b/FunctionSpace/LineLagrangeBasis.cpp
@@ -1,9 +1,8 @@
-#include "Exception.h"
#include "LineLagrangeBasis.h"
#include "pointsGenerators.h"
#include "ElementType.h"
-LineLagrangeBasis::LineLagrangeBasis(unsigned int order){
+LineLagrangeBasis::LineLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1
if(order == 0)
order = 1;
@@ -21,26 +20,13 @@ LineLagrangeBasis::LineLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis //
- lBasis = new polynomialBasis(getTag(order));
+ lBasis = new polynomialBasis(ElementType::getTag(TYPE_LIN, order, false));
// Init Lagrange Point //
- lPoint = new fullMatrix<double>
- (gmshGeneratePointsLine(order));
+ lPoint = new fullMatrix<double>(gmshGeneratePointsLine(order));
}
LineLagrangeBasis::~LineLagrangeBasis(void){
delete lBasis;
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);
-}
diff --git a/FunctionSpace/LineLagrangeBasis.h b/FunctionSpace/LineLagrangeBasis.h
index af48c318d8f729a36f226c598009437547601a91..d7a057484996a0f60f1c23339d094808735237e6 100644
--- a/FunctionSpace/LineLagrangeBasis.h
+++ b/FunctionSpace/LineLagrangeBasis.h
@@ -20,17 +20,11 @@ class LineLagrangeBasis: public BasisLagrange{
//!
//! Returns a new LineLagrangeBasis
//! of the given Order
- LineLagrangeBasis(unsigned int order);
+ LineLagrangeBasis(size_t order);
//! Deletes this Basis
//!
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
diff --git a/FunctionSpace/QuadLagrangeBasis.cpp b/FunctionSpace/QuadLagrangeBasis.cpp
index db80145778caa9ecfd4bc3187796b64a18474a4e..9367c4f7273a8e50e0c2d6cce2c7411fe2164587 100644
--- a/FunctionSpace/QuadLagrangeBasis.cpp
+++ b/FunctionSpace/QuadLagrangeBasis.cpp
@@ -1,9 +1,8 @@
-#include "Exception.h"
#include "QuadLagrangeBasis.h"
#include "pointsGenerators.h"
#include "ElementType.h"
-QuadLagrangeBasis::QuadLagrangeBasis(unsigned int order){
+QuadLagrangeBasis::QuadLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1
if(order == 0)
order = 1;
@@ -21,26 +20,13 @@ QuadLagrangeBasis::QuadLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis //
- lBasis = new polynomialBasis(getTag(order));
+ lBasis = new polynomialBasis(ElementType::getTag(TYPE_QUA, order, false));
// Init Lagrange Point //
- lPoint = new fullMatrix<double>
- (gmshGeneratePointsQuadrangle(order, false));
+ lPoint = new fullMatrix<double>(gmshGeneratePointsQuadrangle(order, false));
}
QuadLagrangeBasis::~QuadLagrangeBasis(void){
delete lBasis;
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);
-}
diff --git a/FunctionSpace/QuadLagrangeBasis.h b/FunctionSpace/QuadLagrangeBasis.h
index b1efbd50d3a0ebbb8296cbd45deaddd480ccd0cf..1b0ad828fb0d5cdcdf6c47f3d59ac3ff709eaced 100644
--- a/FunctionSpace/QuadLagrangeBasis.h
+++ b/FunctionSpace/QuadLagrangeBasis.h
@@ -20,17 +20,11 @@ class QuadLagrangeBasis: public BasisLagrange{
//!
//! Returns a new QuadLagrangeBasis
//! of the given Order
- QuadLagrangeBasis(unsigned int order);
+ QuadLagrangeBasis(size_t order);
//! Deletes this Basis
//!
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
diff --git a/FunctionSpace/ReferenceSpaceLagrange.cpp b/FunctionSpace/ReferenceSpaceLagrange.cpp
deleted file mode 100644
index 6c088a3027ce3ba3c962881d35fa026f042fdc88..0000000000000000000000000000000000000000
--- a/FunctionSpace/ReferenceSpaceLagrange.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-#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();
-}
diff --git a/FunctionSpace/ReferenceSpaceLagrange.h b/FunctionSpace/ReferenceSpaceLagrange.h
deleted file mode 100644
index 62f65b42ab2fd6aa0cf86de625a87a93092b690a..0000000000000000000000000000000000000000
--- a/FunctionSpace/ReferenceSpaceLagrange.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#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
diff --git a/FunctionSpace/TetLagrangeBasis.cpp b/FunctionSpace/TetLagrangeBasis.cpp
index 71ed96c451de9ca42c83e20a6139880c978e72d1..3aaf26ca793ca0414b079f949d1d71d559042c49 100644
--- a/FunctionSpace/TetLagrangeBasis.cpp
+++ b/FunctionSpace/TetLagrangeBasis.cpp
@@ -1,9 +1,8 @@
-#include "Exception.h"
#include "TetLagrangeBasis.h"
#include "pointsGenerators.h"
#include "ElementType.h"
-TetLagrangeBasis::TetLagrangeBasis(unsigned int order){
+TetLagrangeBasis::TetLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1
if(order == 0)
order = 1;
@@ -21,26 +20,13 @@ TetLagrangeBasis::TetLagrangeBasis(unsigned int order){
nFunction = nVertex + nEdge + nFace + nCell;
// Init polynomialBasis //
- lBasis = new polynomialBasis(getTag(order));
+ lBasis = new polynomialBasis(ElementType::getTag(TYPE_TET, order, false));
// Init Lagrange Point //
- lPoint = new fullMatrix<double>
- (gmshGeneratePointsTetrahedron(order, false));
+ lPoint = new fullMatrix<double>(gmshGeneratePointsTetrahedron(order, false));
}
TetLagrangeBasis::~TetLagrangeBasis(void){
delete lBasis;
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);
-}
diff --git a/FunctionSpace/TetLagrangeBasis.h b/FunctionSpace/TetLagrangeBasis.h
index ef7d8db129286fbf533e4bc173d586dcdd3382bc..97b02a31bf59a8d59a95987a12965afe4a494ff6 100644
--- a/FunctionSpace/TetLagrangeBasis.h
+++ b/FunctionSpace/TetLagrangeBasis.h
@@ -20,17 +20,11 @@ class TetLagrangeBasis: public BasisLagrange{
//!
//! Returns a new TetLagrangeBasis
//! of the given Order
- TetLagrangeBasis(unsigned int order);
+ TetLagrangeBasis(size_t order);
//! Deletes this Basis
//!
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
diff --git a/FunctionSpace/TriLagrangeBasis.cpp b/FunctionSpace/TriLagrangeBasis.cpp
index a6d4073b739984fba46efa51061dfc4ff47a2550..6a4a052731cdff18510dcb8d59a09112fc3fda93 100644
--- a/FunctionSpace/TriLagrangeBasis.cpp
+++ b/FunctionSpace/TriLagrangeBasis.cpp
@@ -1,9 +1,8 @@
#include "TriLagrangeBasis.h"
#include "pointsGenerators.h"
-//#include "TriReferenceSpace.h"
#include "ElementType.h"
-TriLagrangeBasis::TriLagrangeBasis(unsigned int order){
+TriLagrangeBasis::TriLagrangeBasis(size_t order){
// If order 0 (Nedelec): use order 1
if(order == 0)
order = 1;
@@ -24,17 +23,10 @@ TriLagrangeBasis::TriLagrangeBasis(unsigned int order){
lBasis = new polynomialBasis(ElementType::getTag(TYPE_TRI, order, false));
// Init Lagrange Point //
- lPoint = new fullMatrix<double>
- (gmshGeneratePointsTriangle(order, false));
-
- // ReferenceSpace //
- // refSpace = new TriReferenceSpace;
- // refSpace = new TriLagrangeReferenceSpace(order);
- // std::cout << refSpace->toString() << std::endl;
+ lPoint = new fullMatrix<double>(gmshGeneratePointsTriangle(order, false));
}
TriLagrangeBasis::~TriLagrangeBasis(void){
delete lBasis;
delete lPoint;
- // delete refSpace;
}
diff --git a/FunctionSpace/TriLagrangeBasis.h b/FunctionSpace/TriLagrangeBasis.h
index a49ab78c9f842ef98e4323a25928baff68e2f440..9092be363118db69baea9c6441f7b0380695a1f1 100644
--- a/FunctionSpace/TriLagrangeBasis.h
+++ b/FunctionSpace/TriLagrangeBasis.h
@@ -20,17 +20,11 @@ class TriLagrangeBasis: public BasisLagrange{
//!
//! Returns a new TriLagrangeBasis
//! of the given Order
- TriLagrangeBasis(unsigned int order);
+ TriLagrangeBasis(size_t order);
//! Deletes this Basis
//!
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
diff --git a/FunctionSpace/TriLagrangeReferenceSpace.cpp b/FunctionSpace/TriLagrangeReferenceSpace.cpp
deleted file mode 100644
index 7ba864c88fc90253dc2f26331f9f9571f9d2c1d6..0000000000000000000000000000000000000000
--- a/FunctionSpace/TriLagrangeReferenceSpace.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#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;
- */
-}
diff --git a/FunctionSpace/TriLagrangeReferenceSpace.h b/FunctionSpace/TriLagrangeReferenceSpace.h
deleted file mode 100644
index bdd26b5cd3c887ad506839a9122bbde3b44d8bf0..0000000000000000000000000000000000000000
--- a/FunctionSpace/TriLagrangeReferenceSpace.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#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