diff --git a/FunctionSpace/Basis.h b/FunctionSpace/Basis.h
index 9c0ceb0e98e85f5c9b100725cc071336def3fafe..8cbd05deea20eb26a8971886779d669a080ca1b9 100644
--- a/FunctionSpace/Basis.h
+++ b/FunctionSpace/Basis.h
@@ -1,6 +1,7 @@
#ifndef _BASIS_H_
#define _BASIS_H_
+#include <string>
#include "MElement.h"
#include "ReferenceSpace.h"
@@ -49,16 +50,16 @@ class Basis{
bool scalar;
bool local;
- unsigned int order;
- unsigned int type;
- unsigned int dim;
+ size_t order;
+ size_t type;
+ size_t dim;
- unsigned int nVertex;
- unsigned int nEdge;
- unsigned int nFace;
- unsigned int nCell;
+ size_t nVertex;
+ size_t nEdge;
+ size_t nFace;
+ size_t nCell;
- unsigned int nFunction;
+ size_t nFunction;
public:
// Destructor //
@@ -69,30 +70,27 @@ class Basis{
bool isLocal(void) const;
// Type of Basis //
- unsigned int getOrder(void) const;
- unsigned int getType(void) const;
- unsigned int getDim(void) const;
+ size_t getOrder(void) const;
+ size_t getType(void) const;
+ size_t getDim(void) const;
// Number of Functions //
- unsigned int getNVertexBased(void) const;
- unsigned int getNEdgeBased(void) const;
- unsigned int getNFaceBased(void) const;
- unsigned int getNCellBased(void) const;
- unsigned int getNFunction(void) const;
+ size_t getNVertexBased(void) const;
+ size_t getNEdgeBased(void) const;
+ size_t getNFaceBased(void) const;
+ size_t getNCellBased(void) const;
+ size_t getNFunction(void) const;
// Reference Element //
const ReferenceSpace& getReferenceSpace(void) const;
- virtual unsigned int getNOrientation(void) const = 0;
- virtual unsigned int getOrientation(const MElement& element) const = 0;
-
// Direct Access to Evaluated Functions //
virtual void getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const = 0;
virtual void getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const = 0;
// Precompute Functions //
@@ -107,10 +105,10 @@ class Basis{
getPreEvaluatedDerivatives(const MElement& element) const = 0;
virtual const fullMatrix<double>&
- getPreEvaluatedFunctions(unsigned int orientation) const = 0;
+ getPreEvaluatedFunctions(size_t orientation) const = 0;
virtual const fullMatrix<double>&
- getPreEvaluatedDerivatives(unsigned int orientation) const = 0;
+ getPreEvaluatedDerivatives(size_t orientation) const = 0;
virtual std::string toString(void) const = 0;
@@ -212,7 +210,7 @@ class Basis{
of the given element
**
- @fn Basis::getFunctions(unsigned int, double, double, double) const
+ @fn Basis::getFunctions(size_t, double, double, double) const
@param orientation A natural number defining the reference space @em orientation
@param u A @c u coordinate in the reference space of this Basis
@param v A @c v coordinate in the reference space of this Basis
@@ -254,7 +252,7 @@ class Basis{
(does it exists -- discontinous field nope ?) ?
**
- @fn Basis::getPreEvaluatedFunctions(unsigned int) const
+ @fn Basis::getPreEvaluatedFunctions(size_t) const
@param orientation A natural number defining the reference space @em orientation
@return Returns a Matrix with the PreEvaluated basis functions
(see Basis::preEvaluateFunctions()), with the given @em orientation
@@ -264,7 +262,7 @@ class Basis{
an Exception is thrown
**
- @fn Basis::getPreEvaluatedDerivatives(unsigned int) const
+ @fn Basis::getPreEvaluatedDerivatives(size_t) const
@param orientation A natural number defining the reference space @em orientation
@return Returns a Matrix with the PreEvaluated basis functions @em derivatives
(see Basis::preEvaluateDerivatives()), with the given @em orientation
@@ -294,35 +292,35 @@ inline bool Basis::isLocal(void) const{
return local;
}
-inline unsigned int Basis::getOrder(void) const{
+inline size_t Basis::getOrder(void) const{
return order;
}
-inline unsigned int Basis::getType(void) const{
+inline size_t Basis::getType(void) const{
return type;
}
-inline unsigned int Basis::getDim(void) const{
+inline size_t Basis::getDim(void) const{
return dim;
}
-inline unsigned int Basis::getNVertexBased(void) const{
+inline size_t Basis::getNVertexBased(void) const{
return nVertex;
}
-inline unsigned int Basis::getNEdgeBased(void) const{
+inline size_t Basis::getNEdgeBased(void) const{
return nEdge;
}
-inline unsigned int Basis::getNFaceBased(void) const{
+inline size_t Basis::getNFaceBased(void) const{
return nFace;
}
-inline unsigned int Basis::getNCellBased(void) const{
+inline size_t Basis::getNCellBased(void) const{
return nCell;
}
-inline unsigned int Basis::getNFunction(void) const{
+inline size_t Basis::getNFunction(void) const{
return nFunction;
}
diff --git a/FunctionSpace/BasisGenerator.cpp b/FunctionSpace/BasisGenerator.cpp
index 90eda2048f1742c42811cc0cb3f8243c9da78ccf..75f7f2c0747a02dad1ca7558a14568c3c01b1f6f 100644
--- a/FunctionSpace/BasisGenerator.cpp
+++ b/FunctionSpace/BasisGenerator.cpp
@@ -32,9 +32,9 @@ BasisGenerator::BasisGenerator(void){
BasisGenerator::~BasisGenerator(void){
}
-BasisLocal* BasisGenerator::generate(unsigned int elementType,
- unsigned int basisType,
- unsigned int order,
+BasisLocal* BasisGenerator::generate(size_t elementType,
+ size_t basisType,
+ size_t order,
std::string family){
if(!family.compare(std::string("hierarchical")))
@@ -47,9 +47,9 @@ BasisLocal* BasisGenerator::generate(unsigned int elementType,
throw Exception("Unknwown Basis Family: %s", family.c_str());
}
-BasisLocal* BasisGenerator::generateHierarchical(unsigned int elementType,
- unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::generateHierarchical(size_t elementType,
+ size_t basisType,
+ size_t order){
switch(elementType){
case TYPE_LIN: return linHierarchicalGen(basisType, order);
case TYPE_TRI: return triHierarchicalGen(basisType, order);
@@ -62,9 +62,9 @@ BasisLocal* BasisGenerator::generateHierarchical(unsigned int elementType,
}
}
-BasisLocal* BasisGenerator::generateLagrange(unsigned int elementType,
- unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::generateLagrange(size_t elementType,
+ size_t basisType,
+ size_t order){
if(basisType != 0)
throw
Exception("Cannot Have a %d-Form Lagrange Basis (0-Form only)",
@@ -82,75 +82,75 @@ BasisLocal* BasisGenerator::generateLagrange(unsigned int elementType,
}
}
-BasisLocal* BasisGenerator::linHierarchicalGen(unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::linHierarchicalGen(size_t basisType,
+ size_t order){
switch(basisType){
- case 0: return new LineNodeBasis(order);
- case 1:
+ case 0: return new LineNodeBasis(order);
+ case 1:
if (order == 0) return new LineNedelecBasis();
else return new LineEdgeBasis(order);
- case 2: throw Exception("2-form not implemented on Lines");
- case 3: throw Exception("3-form not implemented on Lines");
+ case 2: throw Exception("2-form not implemented on Lines");
+ case 3: throw Exception("3-form not implemented on Lines");
default: throw Exception("There is no %d-form", basisType);
}
}
-BasisLocal* BasisGenerator::triHierarchicalGen(unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::triHierarchicalGen(size_t basisType,
+ size_t order){
switch(basisType){
- case 0: return new TriNodeBasis(order);
- case 1:
+ case 0: return new TriNodeBasis(order);
+ case 1:
if (order == 0) return new TriNedelecBasis();
else return new TriEdgeBasis(order);
- case 2: throw Exception("2-form not implemented on Triangles");
- case 3: throw Exception("3-form not implemented on Triangles");
+ case 2: throw Exception("2-form not implemented on Triangles");
+ case 3: throw Exception("3-form not implemented on Triangles");
default: throw Exception("There is no %d-form", basisType);
}
}
-BasisLocal* BasisGenerator::quaHierarchicalGen(unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::quaHierarchicalGen(size_t basisType,
+ size_t order){
switch(basisType){
- case 0: return new QuadNodeBasis(order);
- case 1:
+ case 0: return new QuadNodeBasis(order);
+ case 1:
if (order == 0) return new QuadNedelecBasis();
else return new QuadEdgeBasis(order);
- case 2: throw Exception("2-form not implemented on Quads");
- case 3: throw Exception("3-form not implemented on Quads");
+ case 2: throw Exception("2-form not implemented on Quads");
+ case 3: throw Exception("3-form not implemented on Quads");
default: throw Exception("There is no %d-form", basisType);
}
}
-BasisLocal* BasisGenerator::tetHierarchicalGen(unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::tetHierarchicalGen(size_t basisType,
+ size_t order){
switch(basisType){
- case 0: return new TetNodeBasis(order);
- case 1:
+ case 0: return new TetNodeBasis(order);
+ case 1:
if (order == 0) return new TetNedelecBasis();
else return new TetEdgeBasis(order);
- case 2: throw Exception("2-form not implemented on Tetrahedrons");
- case 3: throw Exception("3-form not implemented on Tetrahedrons");
+ case 2: throw Exception("2-form not implemented on Tetrahedrons");
+ case 3: throw Exception("3-form not implemented on Tetrahedrons");
default: throw Exception("There is no %d-form", basisType);
}
}
-BasisLocal* BasisGenerator::hexHierarchicalGen(unsigned int basisType,
- unsigned int order){
+BasisLocal* BasisGenerator::hexHierarchicalGen(size_t basisType,
+ size_t order){
switch(basisType){
- //case 0: return new HexNodeBasis(order);
- //case 1: return new HexEdgeBasis(order);
- case 0: throw Exception("0-form not implemented on Hexs");
- case 1: throw Exception("1-form not implemented on Hexs");
- case 2: throw Exception("2-form not implemented on Hexs");
- case 3: throw Exception("3-form not implemented on Hexs");
+ //case 0: return new HexNodeBasis(order);
+ //case 1: return new HexEdgeBasis(order);
+ case 0: throw Exception("0-form not implemented on Hexs");
+ case 1: throw Exception("1-form not implemented on Hexs");
+ case 2: throw Exception("2-form not implemented on Hexs");
+ case 3: throw Exception("3-form not implemented on Hexs");
default: throw Exception("There is no %d-form", basisType);
}
diff --git a/FunctionSpace/BasisGenerator.h b/FunctionSpace/BasisGenerator.h
index 84508593340d23b106e32067c67d89443a3f4054..fc1e4d986fe5b854cfc629e52f2b3ef7a0d0d91f 100644
--- a/FunctionSpace/BasisGenerator.h
+++ b/FunctionSpace/BasisGenerator.h
@@ -21,29 +21,29 @@ class BasisGenerator{
BasisGenerator(void);
~BasisGenerator(void);
- static BasisLocal* generate(unsigned int elementType,
- unsigned int basisType,
- unsigned int order,
- std::string family);
+ static BasisLocal* generate(size_t elementType,
+ size_t basisType,
+ size_t order,
+ std::string family);
- static BasisLocal* generate(unsigned int elementType,
- unsigned int basisType,
- unsigned int order);
+ static BasisLocal* generate(size_t elementType,
+ size_t basisType,
+ size_t order);
- static BasisLocal* linHierarchicalGen(unsigned int basisType, unsigned int order);
- static BasisLocal* triHierarchicalGen(unsigned int basisType, unsigned int order);
- static BasisLocal* quaHierarchicalGen(unsigned int basisType, unsigned int order);
- static BasisLocal* tetHierarchicalGen(unsigned int basisType, unsigned int order);
- static BasisLocal* hexHierarchicalGen(unsigned int basisType, unsigned int order);
+ static BasisLocal* linHierarchicalGen(size_t basisType, size_t order);
+ static BasisLocal* triHierarchicalGen(size_t basisType, size_t order);
+ static BasisLocal* quaHierarchicalGen(size_t basisType, size_t order);
+ static BasisLocal* tetHierarchicalGen(size_t basisType, size_t order);
+ static BasisLocal* hexHierarchicalGen(size_t basisType, size_t order);
private:
- static BasisLocal* generateHierarchical(unsigned int elementType,
- unsigned int basisType,
- unsigned int order);
+ static BasisLocal* generateHierarchical(size_t elementType,
+ size_t basisType,
+ size_t order);
- static BasisLocal* generateLagrange(unsigned int elementType,
- unsigned int basisType,
- unsigned int order);
+ static BasisLocal* generateLagrange(size_t elementType,
+ size_t basisType,
+ size_t order);
};
@@ -60,7 +60,7 @@ class BasisGenerator{
Deletes this BasisGenerator
**
- @fn BasisGenerator::generate(unsigned int, unsigned int, unsigned int, std::string)
+ @fn BasisGenerator::generate(size_t, size_t, size_t, std::string)
@param elementType The type of the element,
on which the requested Basis will be created
@param basisType The Basis type
@@ -93,7 +93,7 @@ class BasisGenerator{
@li @c lagrange for Lagrange's Basis Functions
**
- @fn BasisGenerator::generate(unsigned int, unsigned int, unsigned int)
+ @fn BasisGenerator::generate(size_t, size_t, size_t)
@param elementType The type of the element,
on which the requested Basis will be created
@param basisType The Basis type
@@ -206,14 +206,14 @@ class BasisGenerator{
// Inline Functions //
//////////////////////
-inline BasisLocal* BasisGenerator::generate(unsigned int elementType,
- unsigned int basisType,
- unsigned int order){
+inline BasisLocal* BasisGenerator::generate(size_t elementType,
+ size_t basisType,
+ size_t order){
return BasisGenerator::generate(elementType,
- basisType,
- order,
- "hierarchical");
+ basisType,
+ order,
+ "hierarchical");
}
#endif
diff --git a/FunctionSpace/BasisHierarchical0From.cpp b/FunctionSpace/BasisHierarchical0Form.cpp
similarity index 66%
rename from FunctionSpace/BasisHierarchical0From.cpp
rename to FunctionSpace/BasisHierarchical0Form.cpp
index 7f5a1597f5b5f5e17aa1890f13edd99cae3e178e..e387b3a318da8b24c0c32c985866ec01470b0fb2 100644
--- a/FunctionSpace/BasisHierarchical0From.cpp
+++ b/FunctionSpace/BasisHierarchical0Form.cpp
@@ -1,10 +1,10 @@
#include <sstream>
#include "Exception.h"
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
using namespace std;
-BasisHierarchical0From::BasisHierarchical0From(void){
+BasisHierarchical0Form::BasisHierarchical0Form(void){
// Scalar Basis ? //
scalar = true;
@@ -20,11 +20,13 @@ BasisHierarchical0From::BasisHierarchical0From(void){
preEvaluatedGradFunction = NULL;
}
-BasisHierarchical0From::~BasisHierarchical0From(void){
+BasisHierarchical0Form::~BasisHierarchical0Form(void){
// Grad Basis //
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
if(hasGrad){
- for(unsigned int i = 0; i < nRefSpace; i++){
- for(unsigned int j = 0; j < nFunction; j++)
+ for(size_t i = 0; i < nRefSpace; i++){
+ for(size_t j = 0; j < nFunction; j++)
delete grad[i][j];
delete[] grad[i];
@@ -35,75 +37,67 @@ BasisHierarchical0From::~BasisHierarchical0From(void){
// PreEvaluation //
if(preEvaluated){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedFunction[i];
delete[] preEvaluatedFunction;
}
if(preEvaluatedGrad){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedGradFunction[i];
delete[] preEvaluatedGradFunction;
}
}
-unsigned int BasisHierarchical0From::
-getNOrientation(void) const{
- return refSpace->getNReferenceSpace();
-}
-
-unsigned int BasisHierarchical0From::
-getOrientation(const MElement& element) const{
- return refSpace->getReferenceSpace(element);
-}
-
-void BasisHierarchical0From::
+void BasisHierarchical0Form::
getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const{
// Define Orientation //
- unsigned int orientation = refSpace->getReferenceSpace(element);
+ const size_t orientation = refSpace->getReferenceSpace(element);
// Fill Matrix //
- for(unsigned int i = 0; i < nFunction; i++)
+ for(size_t i = 0; i < nFunction; i++)
retValues(i, 0) = basis[orientation][i]->at(u, v, w);
}
-void BasisHierarchical0From::
+void BasisHierarchical0Form::
getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const{
// Fill Matrix //
- for(unsigned int i = 0; i < nFunction; i++)
+ for(size_t i = 0; i < nFunction; i++)
retValues(i, 0) = basis[orientation][i]->at(u, v, w);
}
-void BasisHierarchical0From::
+void BasisHierarchical0Form::
preEvaluateFunctions(const fullMatrix<double>& point) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Delete if older //
if(preEvaluated){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedFunction[i];
delete[] preEvaluatedFunction;
}
// Alloc //
- const unsigned int nPoint = point.size1();
+ const size_t nPoint = point.size1();
preEvaluatedFunction = new fullMatrix<double>*[nRefSpace];
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
preEvaluatedFunction[i] =
new fullMatrix<double>(nFunction, nPoint);
// Fill Matrix //
- for(unsigned int i = 0; i < nRefSpace; i++)
- for(unsigned int j = 0; j < nFunction; j++)
- for(unsigned int k = 0; k < nPoint; k++)
+ for(size_t i = 0; i < nRefSpace; i++)
+ for(size_t j = 0; j < nFunction; j++)
+ for(size_t k = 0; k < nPoint; k++)
(*preEvaluatedFunction[i])(j, k) =
basis[i][j]->at(point(k, 0),
point(k, 1),
@@ -113,35 +107,37 @@ preEvaluateFunctions(const fullMatrix<double>& point) const{
preEvaluated = true;
}
-void BasisHierarchical0From::
+void BasisHierarchical0Form::
preEvaluateDerivatives(const fullMatrix<double>& point) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Build Grad //
if(!hasGrad)
getGrad();
// Delete if older //
if(preEvaluatedGrad){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedGradFunction[i];
delete[] preEvaluatedGradFunction;
}
// Alloc //
- const unsigned int nPoint = point.size1();
- const unsigned int nPoint3 = nPoint * 3;
+ const size_t nPoint = point.size1();
+ const size_t nPoint3 = nPoint * 3;
preEvaluatedGradFunction = new fullMatrix<double>*[nRefSpace];
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
preEvaluatedGradFunction[i] =
new fullMatrix<double>(nFunction, nPoint3);
// Fill Matrix //
fullVector<double> tmp(3);
- for(unsigned int i = 0; i < nRefSpace; i++){
- for(unsigned int j = 0; j < nFunction; j++){
- for(unsigned int k = 0; k < nPoint; k++){
+ for(size_t i = 0; i < nRefSpace; i++){
+ for(size_t j = 0; j < nFunction; j++){
+ for(size_t k = 0; k < nPoint; k++){
tmp = Polynomial::at(*grad[i][j],
point(k, 0),
point(k, 1),
@@ -158,42 +154,44 @@ preEvaluateDerivatives(const fullMatrix<double>& point) const{
preEvaluatedGrad = true;
}
-const fullMatrix<double>& BasisHierarchical0From::
+const fullMatrix<double>& BasisHierarchical0Form::
getPreEvaluatedFunctions(const MElement& element) const{
return getPreEvaluatedFunctions(refSpace->getReferenceSpace(element));
}
-const fullMatrix<double>& BasisHierarchical0From::
+const fullMatrix<double>& BasisHierarchical0Form::
getPreEvaluatedDerivatives(const MElement& element) const{
return getPreEvaluatedDerivatives(refSpace->getReferenceSpace(element));
}
-const fullMatrix<double>& BasisHierarchical0From::
-getPreEvaluatedFunctions(unsigned int orientation) const{
+const fullMatrix<double>& BasisHierarchical0Form::
+getPreEvaluatedFunctions(size_t orientation) const{
if(!preEvaluated)
throw Exception("getPreEvaluatedFunction: function has not been preEvaluated");
return *preEvaluatedFunction[orientation];
}
-const fullMatrix<double>& BasisHierarchical0From::
-getPreEvaluatedDerivatives(unsigned int orientation) const{
+const fullMatrix<double>& BasisHierarchical0Form::
+getPreEvaluatedDerivatives(size_t orientation) const{
if(!preEvaluatedGrad)
throw Exception("getPreEvaluatedDerivative: gradient has not been preEvaluated");
return *preEvaluatedGradFunction[orientation];
}
-void BasisHierarchical0From::getGrad(void) const{
+void BasisHierarchical0Form::getGrad(void) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Alloc //
grad = new vector<Polynomial>**[nRefSpace];
- for(unsigned int s = 0; s < nRefSpace; s++)
+ for(size_t s = 0; s < nRefSpace; s++)
grad[s] = new vector<Polynomial>*[nFunction];
// Grad //
- for(unsigned int s = 0; s < nRefSpace; s++)
- for(unsigned int f = 0 ; f < nFunction; f++)
+ for(size_t s = 0; s < nRefSpace; s++)
+ for(size_t f = 0 ; f < nFunction; f++)
grad[s][f] =
new vector<Polynomial>(basis[s][f]->gradient());
@@ -201,10 +199,10 @@ void BasisHierarchical0From::getGrad(void) const{
hasGrad = true;
}
-string BasisHierarchical0From::toString(void) const{
+string BasisHierarchical0Form::toString(void) const{
stringstream stream;
- unsigned int i = 0;
- const unsigned int refSpace = 0;
+ size_t i = 0;
+ const size_t refSpace = 0;
stream << "Vertex Based:" << endl;
for(; i < nVertex; i++)
diff --git a/FunctionSpace/BasisHierarchical0From.h b/FunctionSpace/BasisHierarchical0Form.h
similarity index 56%
rename from FunctionSpace/BasisHierarchical0From.h
rename to FunctionSpace/BasisHierarchical0Form.h
index b2ee85c0edf9fbfdb6d05a87cfc33421ba41c763..ecdc6627a7cb1490dc1ec6cde8d8faec7431c71a 100644
--- a/FunctionSpace/BasisHierarchical0From.h
+++ b/FunctionSpace/BasisHierarchical0Form.h
@@ -1,23 +1,18 @@
-#ifndef _BASISHIERARCHICAL0FROM_H_
-#define _BASISHIERARCHICAL0FROM_H_
+#ifndef _BASISHIERARCHICAL0FORM_H_
+#define _BASISHIERARCHICAL0FORM_H_
-#include <string>
#include "BasisLocal.h"
#include "Polynomial.h"
-#include "ReferenceSpace.h"
/**
- @interface BasisHierarchical0From
- @brief Interface for Hierarchical 0-From Local Basis
+ @interface BasisHierarchical0Form
+ @brief Interface for Hierarchical 0-Form Local Basis
- This is an interface for Hierarchical 0-From Local Basis.@n
+ This is an interface for Hierarchical 0-Form Local Basis.@n
*/
-class BasisHierarchical0From: public BasisLocal{
+class BasisHierarchical0Form: public BasisLocal{
protected:
- // Orientation //
- unsigned int nRefSpace;
-
// Basis //
Polynomial*** basis;
@@ -33,17 +28,14 @@ class BasisHierarchical0From: public BasisLocal{
mutable fullMatrix<double>** preEvaluatedGradFunction;
public:
- virtual ~BasisHierarchical0From(void);
-
- virtual unsigned int getNOrientation(void) const;
- virtual unsigned int getOrientation(const MElement& element) const;
+ virtual ~BasisHierarchical0Form(void);
virtual void getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const;
virtual void getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const;
virtual void preEvaluateFunctions(const fullMatrix<double>& point) const;
@@ -56,15 +48,15 @@ class BasisHierarchical0From: public BasisLocal{
getPreEvaluatedDerivatives(const MElement& element) const;
virtual const fullMatrix<double>&
- getPreEvaluatedFunctions(unsigned int orientation) const;
+ getPreEvaluatedFunctions(size_t orientation) const;
virtual const fullMatrix<double>&
- getPreEvaluatedDerivatives(unsigned int orientation) const;
+ getPreEvaluatedDerivatives(size_t orientation) const;
std::string toString(void) const;
protected:
- BasisHierarchical0From(void);
+ BasisHierarchical0Form(void);
private:
void getGrad(void) const;
@@ -72,20 +64,20 @@ class BasisHierarchical0From: public BasisLocal{
/**
@internal
- @fn BasisHierarchical0From::BasisHierarchical0From
+ @fn BasisHierarchical0Form::BasisHierarchical0Form
- Instanciates an new BasisHierarchical0From
+ Instanciates an new BasisHierarchical0Form
@endinternal
**
- @fn BasisHierarchical0From::~BasisHierarchical0From
+ @fn BasisHierarchical0Form::~BasisHierarchical0Form
- Deletes this BasisHierarchical0From
+ Deletes this BasisHierarchical0Form
**
- @fn BasisHierarchical0From::toString
+ @fn BasisHierarchical0Form::toString
@return Returns a string describing this
- BasisHierarchical0From
+ BasisHierarchical0Form
*/
#endif
diff --git a/FunctionSpace/BasisHierarchical1From.cpp b/FunctionSpace/BasisHierarchical1Form.cpp
similarity index 71%
rename from FunctionSpace/BasisHierarchical1From.cpp
rename to FunctionSpace/BasisHierarchical1Form.cpp
index ea8e5442e1659fdb1cf4b9ab6bc710ddead33ffa..8c197e826b5013878ae7407927678294ccfc4e1d 100644
--- a/FunctionSpace/BasisHierarchical1From.cpp
+++ b/FunctionSpace/BasisHierarchical1Form.cpp
@@ -1,10 +1,10 @@
#include <sstream>
#include "Exception.h"
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
using namespace std;
-BasisHierarchical1From::BasisHierarchical1From(void){
+BasisHierarchical1Form::BasisHierarchical1Form(void){
// Scalar Basis ?//
scalar = false;
@@ -20,11 +20,13 @@ BasisHierarchical1From::BasisHierarchical1From(void){
preEvaluatedCurlFunction = NULL;
}
-BasisHierarchical1From::~BasisHierarchical1From(void){
+BasisHierarchical1Form::~BasisHierarchical1Form(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Curl Basis //
if(hasCurl){
- for(unsigned int i = 0; i < nRefSpace; i++){
- for(unsigned int j = 0; j < nFunction; j++)
+ for(size_t i = 0; i < nRefSpace; i++){
+ for(size_t j = 0; j < nFunction; j++)
delete curl[i][j];
delete[] curl[i];
@@ -35,40 +37,30 @@ BasisHierarchical1From::~BasisHierarchical1From(void){
// PreEvaluation //
if(preEvaluated){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedFunction[i];
delete[] preEvaluatedFunction;
}
if(preEvaluatedCurl){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedCurlFunction[i];
delete[] preEvaluatedCurlFunction;
}
}
-unsigned int BasisHierarchical1From::
-getNOrientation(void) const{
- return refSpace->getNReferenceSpace();
-}
-
-unsigned int BasisHierarchical1From::
-getOrientation(const MElement& element) const{
- return refSpace->getReferenceSpace(element);
-}
-
-void BasisHierarchical1From::
+void BasisHierarchical1Form::
getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const{
// Define Orientation //
- unsigned int orientation = refSpace->getReferenceSpace(element);
+ size_t orientation = refSpace->getReferenceSpace(element);
// Fill Vector //
- for(unsigned int i = 0; i < nFunction; i++){
+ for(size_t i = 0; i < nFunction; i++){
fullVector<double> eval =
Polynomial::at(*basis[orientation][i], u, v, w);
@@ -78,13 +70,13 @@ getFunctions(fullMatrix<double>& retValues,
}
}
-void BasisHierarchical1From::
+void BasisHierarchical1Form::
getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const{
// Fill Vector //
- for(unsigned int i = 0; i < nFunction; i++){
+ for(size_t i = 0; i < nFunction; i++){
fullVector<double> eval =
Polynomial::at(*basis[orientation][i], u, v, w);
@@ -94,31 +86,33 @@ getFunctions(fullMatrix<double>& retValues,
}
}
-void BasisHierarchical1From::
+void BasisHierarchical1Form::
preEvaluateFunctions(const fullMatrix<double>& point) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Delete if older //
if(preEvaluated){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedFunction[i];
delete[] preEvaluatedFunction;
}
// Alloc //
- const unsigned int nPoint = point.size1();
- const unsigned int nPoint3 = nPoint * 3;
+ const size_t nPoint = point.size1();
+ const size_t nPoint3 = nPoint * 3;
preEvaluatedFunction = new fullMatrix<double>*[nRefSpace];
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
preEvaluatedFunction[i] =
new fullMatrix<double>(nFunction, nPoint3);
// Fill Matrix //
fullVector<double> tmp(3);
- for(unsigned int i = 0; i < nRefSpace; i++){
- for(unsigned int j = 0; j < nFunction; j++){
- for(unsigned int k = 0; k < nPoint; k++){
+ for(size_t i = 0; i < nRefSpace; i++){
+ for(size_t j = 0; j < nFunction; j++){
+ for(size_t k = 0; k < nPoint; k++){
tmp = Polynomial::at(*basis[i][j],
point(k, 0),
point(k, 1),
@@ -135,35 +129,37 @@ preEvaluateFunctions(const fullMatrix<double>& point) const{
preEvaluated = true;
}
-void BasisHierarchical1From::
+void BasisHierarchical1Form::
preEvaluateDerivatives(const fullMatrix<double>& point) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Build Curl //
if(!hasCurl)
getCurl();
// Delete if older //
if(preEvaluatedCurl){
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
delete preEvaluatedCurlFunction[i];
delete[] preEvaluatedCurlFunction;
}
// Alloc //
- const unsigned int nPoint = point.size1();
- const unsigned int nPoint3 = nPoint * 3;
+ const size_t nPoint = point.size1();
+ const size_t nPoint3 = nPoint * 3;
preEvaluatedCurlFunction = new fullMatrix<double>*[nRefSpace];
- for(unsigned int i = 0; i < nRefSpace; i++)
+ for(size_t i = 0; i < nRefSpace; i++)
preEvaluatedCurlFunction[i] =
new fullMatrix<double>(nFunction, nPoint3);
// Fill Matrix //
fullVector<double> tmp(3);
- for(unsigned int i = 0; i < nRefSpace; i++){
- for(unsigned int j = 0; j < nFunction; j++){
- for(unsigned int k = 0; k < nPoint; k++){
+ for(size_t i = 0; i < nRefSpace; i++){
+ for(size_t j = 0; j < nFunction; j++){
+ for(size_t k = 0; k < nPoint; k++){
tmp = Polynomial::at(*curl[i][j],
point(k, 0),
point(k, 1),
@@ -180,42 +176,44 @@ preEvaluateDerivatives(const fullMatrix<double>& point) const{
preEvaluatedCurl = true;
}
-const fullMatrix<double>& BasisHierarchical1From::
+const fullMatrix<double>& BasisHierarchical1Form::
getPreEvaluatedFunctions(const MElement& element) const{
return getPreEvaluatedFunctions(refSpace->getReferenceSpace(element));
}
-const fullMatrix<double>& BasisHierarchical1From::
+const fullMatrix<double>& BasisHierarchical1Form::
getPreEvaluatedDerivatives(const MElement& element) const{
return getPreEvaluatedDerivatives(refSpace->getReferenceSpace(element));
}
-const fullMatrix<double>& BasisHierarchical1From::
-getPreEvaluatedFunctions(unsigned int orientation) const{
+const fullMatrix<double>& BasisHierarchical1Form::
+getPreEvaluatedFunctions(size_t orientation) const{
if(!preEvaluated)
throw Exception("getPreEvaluatedFunction: function has not been preEvaluated");
return *preEvaluatedFunction[orientation];
}
-const fullMatrix<double>& BasisHierarchical1From::
-getPreEvaluatedDerivatives(unsigned int orientation) const{
+const fullMatrix<double>& BasisHierarchical1Form::
+getPreEvaluatedDerivatives(size_t orientation) const{
if(!preEvaluatedCurl)
throw Exception("getPreEvaluatedDerivative: curl has not been preEvaluated");
return *preEvaluatedCurlFunction[orientation];
}
-void BasisHierarchical1From::getCurl(void) const{
+void BasisHierarchical1Form::getCurl(void) const{
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// Alloc //
curl = new vector<Polynomial>**[nRefSpace];
- for(unsigned int s = 0; s < nRefSpace; s++)
+ for(size_t s = 0; s < nRefSpace; s++)
curl[s] = new vector<Polynomial>*[nFunction];
// Curl //
- for(unsigned int s = 0; s < nRefSpace; s++)
- for(unsigned int f = 0 ; f < nFunction; f++)
+ for(size_t s = 0; s < nRefSpace; s++)
+ for(size_t f = 0 ; f < nFunction; f++)
curl[s][f] =
new vector<Polynomial>(Polynomial::curl(*basis[s][f]));
@@ -223,10 +221,10 @@ void BasisHierarchical1From::getCurl(void) const{
hasCurl = true;
}
-string BasisHierarchical1From::toString(void) const{
+string BasisHierarchical1Form::toString(void) const{
stringstream stream;
- unsigned int i = 0;
- const unsigned int refSpace = 0;
+ size_t i = 0;
+ const size_t refSpace = 0;
stream << "Vertex Based:" << endl;
for(; i < nVertex; i++)
diff --git a/FunctionSpace/BasisHierarchical1From.h b/FunctionSpace/BasisHierarchical1Form.h
similarity index 57%
rename from FunctionSpace/BasisHierarchical1From.h
rename to FunctionSpace/BasisHierarchical1Form.h
index 9c67fca2c4931723fac29193c5d11151361ef5c9..48e32d892d1f381037532e87bb479145e075d828 100644
--- a/FunctionSpace/BasisHierarchical1From.h
+++ b/FunctionSpace/BasisHierarchical1Form.h
@@ -1,23 +1,18 @@
-#ifndef _BASISHIERARCHICAL1FROM_H_
-#define _BASISHIERARCHICAL1FROM_H_
+#ifndef _BASISHIERARCHICAL1FORM_H_
+#define _BASISHIERARCHICAL1FORM_H_
-#include <string>
#include "BasisLocal.h"
#include "Polynomial.h"
-#include "ReferenceSpace.h"
/**
- @interface BasisHierarchical1From
- @brief Interface for Hierarchical 1-Froml Local Basis
+ @interface BasisHierarchical1Form
+ @brief Interface for Hierarchical 1-Form Local Basis
- This is an interface for Hierarchical 1-Froml Local Basis.@n
+ This is an interface for Hierarchical 1-Form Local Basis.@n
*/
-class BasisHierarchical1From: public BasisLocal{
+class BasisHierarchical1Form: public BasisLocal{
protected:
- // Orientation //
- unsigned int nRefSpace;
-
// Basis //
std::vector<Polynomial>*** basis;
@@ -33,17 +28,14 @@ class BasisHierarchical1From: public BasisLocal{
mutable fullMatrix<double>** preEvaluatedCurlFunction;
public:
- virtual ~BasisHierarchical1From(void);
-
- virtual unsigned int getNOrientation(void) const;
- virtual unsigned int getOrientation(const MElement& element) const;
+ virtual ~BasisHierarchical1Form(void);
virtual void getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const;
virtual void getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const;
virtual void preEvaluateFunctions(const fullMatrix<double>& point) const;
@@ -56,15 +48,15 @@ class BasisHierarchical1From: public BasisLocal{
getPreEvaluatedDerivatives(const MElement& element) const;
virtual const fullMatrix<double>&
- getPreEvaluatedFunctions(unsigned int orientation) const;
+ getPreEvaluatedFunctions(size_t orientation) const;
virtual const fullMatrix<double>&
- getPreEvaluatedDerivatives(unsigned int orientation) const;
+ getPreEvaluatedDerivatives(size_t orientation) const;
std::string toString(void) const;
protected:
- BasisHierarchical1From(void);
+ BasisHierarchical1Form(void);
private:
void getCurl(void) const;
@@ -72,20 +64,20 @@ class BasisHierarchical1From: public BasisLocal{
/**
@internal
- @fn BasisHierarchical1From::BasisHierarchical1From
+ @fn BasisHierarchical1Form::BasisHierarchical1Form
- Instanciates an new BasisHierarchical1From
+ Instanciates an new BasisHierarchical1Form
@endinternal
**
- @fn BasisHierarchical1From::~BasisHierarchical1From
+ @fn BasisHierarchical1Form::~BasisHierarchical1Form
- Deletes this BasisHierarchical1From
+ Deletes this BasisHierarchical1Form
**
- @fn BasisHierarchical1From::toString
+ @fn BasisHierarchical1Form::toString
@return Returns a string describing this
- BasisHierarchical1From
+ BasisHierarchical1Form
*/
#endif
diff --git a/FunctionSpace/BasisLagrange.cpp b/FunctionSpace/BasisLagrange.cpp
index 7e5584cd16160cac62a7e3124e7a18e83d0801a9..df435aab1bbb4431e1331b0c0e744c25a0350f27 100644
--- a/FunctionSpace/BasisLagrange.cpp
+++ b/FunctionSpace/BasisLagrange.cpp
@@ -20,15 +20,6 @@ BasisLagrange::~BasisLagrange(void){
delete preEvaluatedGradFunction;
}
-unsigned int BasisLagrange::
-getNOrientation(void) const{
- return 1;
-}
-
-unsigned int BasisLagrange::
-getOrientation(const MElement& element) const{
- return 0;
-}
/*
static bool
sortPredicate(const std::pair<size_t, size_t>& a,
@@ -164,7 +155,7 @@ getFunctions(fullMatrix<double>& retValues,
void BasisLagrange::
getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const{
// Fill Matrix //
@@ -223,12 +214,12 @@ BasisLagrange::getPreEvaluatedDerivatives(const MElement& element) const{
}
const fullMatrix<double>&
-BasisLagrange::getPreEvaluatedFunctions(unsigned int orientation) const{
+BasisLagrange::getPreEvaluatedFunctions(size_t orientation) const{
return *preEvaluatedFunction;
}
const fullMatrix<double>&
-BasisLagrange::getPreEvaluatedDerivatives(unsigned int orientation) const{
+BasisLagrange::getPreEvaluatedDerivatives(size_t orientation) const{
return *preEvaluatedGradFunction;
}
@@ -238,13 +229,13 @@ project(const MElement& element,
const FunctionSpaceScalar& fSpace){
// Init New Coefs //
- const unsigned int size = lPoint->size1();
- const unsigned int dim = lPoint->size2();
+ const size_t size = lPoint->size1();
+ const size_t dim = lPoint->size2();
vector<double> newCoef(size);
// Interpolation at Lagrange Points //
- for(unsigned int i = 0; i < size; i++){
+ for(size_t i = 0; i < size; i++){
fullVector<double> uvw(3);
if(dim > 0)
@@ -277,11 +268,11 @@ project(const MElement& element,
const FunctionSpaceVector& fSpace){
// Init New Coefs //
- const unsigned int size = lPoint->size1();
+ const size_t size = lPoint->size1();
vector<fullVector<double> > newCoef(size);
// Interpolation at Lagrange Points //
- for(unsigned int i = 0; i < size; i++){
+ for(size_t i = 0; i < size; i++){
fullVector<double> uvw(3);
if(dim > 0)
diff --git a/FunctionSpace/BasisLagrange.h b/FunctionSpace/BasisLagrange.h
index 913be52da98aa8d617ccc5f834350eb781869c98..4124edfab995ef9fb40926febe1320b7a6597ba5 100644
--- a/FunctionSpace/BasisLagrange.h
+++ b/FunctionSpace/BasisLagrange.h
@@ -6,7 +6,6 @@
#include "FunctionSpaceVector.h"
#include "fullMatrix.h"
#include "polynomialBasis.h"
-// #include "ReferenceSpace.h"
/**
@interface BasisLagrange
@@ -28,7 +27,6 @@ class BasisLagrange: public BasisLocal{
protected:
polynomialBasis* lBasis; // Lagrange Basis
fullMatrix<double>* lPoint; // Lagrange Points
- // ReferenceSpace* refSpace; // RefSpace
// PreEvaluation //
mutable bool preEvaluated;
@@ -40,15 +38,12 @@ class BasisLagrange: public BasisLocal{
public:
virtual ~BasisLagrange(void);
- virtual unsigned int getNOrientation(void) const;
- virtual unsigned int getOrientation(const MElement& element) const;
-
virtual void getFunctions(fullMatrix<double>& retValues,
const MElement& element,
double u, double v, double w) const;
virtual void getFunctions(fullMatrix<double>& retValues,
- unsigned int orientation,
+ size_t orientation,
double u, double v, double w) const;
virtual void preEvaluateFunctions(const fullMatrix<double>& point) const;
@@ -61,10 +56,10 @@ class BasisLagrange: public BasisLocal{
getPreEvaluatedDerivatives(const MElement& element) const;
virtual const fullMatrix<double>&
- getPreEvaluatedFunctions(unsigned int orientation) const;
+ getPreEvaluatedFunctions(size_t orientation) const;
virtual const fullMatrix<double>&
- getPreEvaluatedDerivatives(unsigned int orientation) const;
+ getPreEvaluatedDerivatives(size_t orientation) const;
const fullMatrix<double>& getCoefficient(void) const;
const fullMatrix<double>& getMonomial(void) const;
diff --git a/FunctionSpace/CMakeLists.txt b/FunctionSpace/CMakeLists.txt
index e59333de60c3aacab885f9f70e3cb8162c4259c4..44ea8b673811a84a41320009ea07aba30f09d83e 100644
--- a/FunctionSpace/CMakeLists.txt
+++ b/FunctionSpace/CMakeLists.txt
@@ -23,8 +23,8 @@ set(SRC
BasisGenerator.cpp
BasisLagrange.cpp
- BasisHierarchical0From.cpp
- BasisHierarchical1From.cpp
+ BasisHierarchical0Form.cpp
+ BasisHierarchical1Form.cpp
LineNodeBasis.cpp
LineEdgeBasis.cpp
@@ -46,8 +46,8 @@ set(SRC
TetNedelecBasis.cpp
TetLagrangeBasis.cpp
-# HexNodeBasis.cpp
-# HexEdgeBasis.cpp
+ HexNodeBasis.cpp
+ HexEdgeBasis.cpp
FunctionSpace.cpp
FunctionSpaceScalar.cpp
diff --git a/FunctionSpace/FunctionSpace.cpp b/FunctionSpace/FunctionSpace.cpp
index ef98d9eae5c8fa0d40f98f71e3b4fc20c42dede9..fd3e2501bfde178f0fb1d6606f56932399bff76c 100644
--- a/FunctionSpace/FunctionSpace.cpp
+++ b/FunctionSpace/FunctionSpace.cpp
@@ -30,9 +30,9 @@ FunctionSpace::~FunctionSpace(void){
// Group //
if(group){
- unsigned int nElement = group->size();
+ size_t nElement = group->size();
- for(unsigned int i = 0; i < nElement; i++)
+ for(size_t i = 0; i < nElement; i++)
delete (*group)[i];
delete group;
}
@@ -92,7 +92,7 @@ void FunctionSpace::build(GroupOfElement& goe,
void FunctionSpace::buildDof(void){
// Get Elements //
- const unsigned int nElement = goe->getNumber();
+ const size_t nElement = goe->getNumber();
const vector<const MElement*>& element = goe->getAll();
// Init Struct //
@@ -103,15 +103,15 @@ void FunctionSpace::buildDof(void){
ElementComparator>;
// Create Dofs //
- for(unsigned int i = 0; i < nElement; i++){
+ for(size_t i = 0; i < nElement; i++){
// Get Dof for this Element
vector<Dof> myDof = getKeys(*(element[i]));
- unsigned int nDof = myDof.size();
+ size_t nDof = myDof.size();
// Add Dof
vector<const Dof*> trueDof(nDof);
- for(unsigned int j = 0; j < nDof; j++)
+ for(size_t j = 0; j < nDof; j++)
insertDof(myDof[j], trueDof, j);
// Create new GroupOfDof
diff --git a/FunctionSpace/FunctionSpace.h b/FunctionSpace/FunctionSpace.h
index 2c9881eda1bd1b6730b6552dd142468c5bb5459c..98ee56d6955f220776befbaef63536755dfdd4fb 100644
--- a/FunctionSpace/FunctionSpace.h
+++ b/FunctionSpace/FunctionSpace.h
@@ -49,11 +49,11 @@ class FunctionSpace{
// Basis //
std::vector<const Basis*>* basis;
- unsigned int nBasis;
- unsigned int fPerVertex;
- unsigned int fPerEdge;
- unsigned int fPerFace;
- unsigned int fPerCell;
+ size_t nBasis;
+ size_t fPerVertex;
+ size_t fPerEdge;
+ size_t fPerFace;
+ size_t fPerCell;
// Scalar Field ? //
bool scalar;
@@ -69,8 +69,8 @@ class FunctionSpace{
virtual ~FunctionSpace(void);
const std::vector<const Basis*>& getBasis(const MElement& element) const;
- const Basis& getBasis(unsigned int i) const;
- unsigned int getNBasis(void) const;
+ const Basis& getBasis(size_t i) const;
+ size_t getNBasis(void) const;
GroupOfElement& getSupport(void) const;
bool isScalar(void) const;
@@ -85,8 +85,8 @@ class FunctionSpace{
const GroupOfDof& getGoDFromElement(const MElement& element) const;
- unsigned int dofNumber(void) const;
- unsigned int groupNumber(void) const;
+ size_t dofNumber(void) const;
+ size_t groupNumber(void) const;
protected:
// Init
@@ -185,11 +185,11 @@ FunctionSpace::getBasis(const MElement& element) const{
return *basis;
}
-inline const Basis& FunctionSpace::getBasis(unsigned int i) const{
+inline const Basis& FunctionSpace::getBasis(size_t i) const{
return *(*basis)[i];
}
-inline unsigned int FunctionSpace::getNBasis(void) const{
+inline size_t FunctionSpace::getNBasis(void) const{
return nBasis;
}
@@ -201,11 +201,11 @@ inline bool FunctionSpace::isScalar(void) const{
return scalar;
}
-inline unsigned int FunctionSpace::dofNumber(void) const{
+inline size_t FunctionSpace::dofNumber(void) const{
return dof->size();
}
-inline unsigned int FunctionSpace::groupNumber(void) const{
+inline size_t FunctionSpace::groupNumber(void) const{
return group->size();
}
diff --git a/FunctionSpace/FunctionSpaceScalar.cpp b/FunctionSpace/FunctionSpaceScalar.cpp
index b1e9e1eaa1f35accf8ad458379bc568f4a671819..c4e96462cfce57a45c564b89db381c1978787966 100644
--- a/FunctionSpace/FunctionSpaceScalar.cpp
+++ b/FunctionSpace/FunctionSpaceScalar.cpp
@@ -16,15 +16,15 @@ interpolateInABC(const MElement& element,
double abc[3]) const{
// Get Basis Functions //
- const unsigned int nFun = (*basis)[0]->getNFunction();
- fullMatrix<double> fun(nFun, 1);
+ const size_t nFun = (*basis)[0]->getNFunction();
+ fullMatrix<double> fun(nFun, 1);
(*basis)[0]->getFunctions(fun, element, abc[0], abc[1], abc[2]);
// Interpolate (in Reference Place) //
double val = 0;
- for(unsigned int i = 0; i < nFun; i++)
+ for(size_t i = 0; i < nFun; i++)
val += fun(i, 0) * coef[i];
// Return Interpolated Value //
diff --git a/FunctionSpace/FunctionSpaceVector.cpp b/FunctionSpace/FunctionSpaceVector.cpp
index 412d206e3bd53469d57f61a0c7634a58845d826b..3f1e5b69ae1636642c74c8f7d77035b415346687 100644
--- a/FunctionSpace/FunctionSpaceVector.cpp
+++ b/FunctionSpace/FunctionSpaceVector.cpp
@@ -24,8 +24,8 @@ interpolateInABC(const MElement& element,
invJac.invertInPlace();
// Get Basis Functions //
- const unsigned int nFun = (*basis)[0]->getNFunction();
- fullMatrix<double> fun(nFun, 3);
+ const size_t nFun = (*basis)[0]->getNFunction();
+ fullMatrix<double> fun(nFun, 3);
(*basis)[0]->getFunctions(fun, element, abc[0], abc[1], abc[2]);
@@ -35,7 +35,7 @@ interpolateInABC(const MElement& element,
val(0, 1) = 0;
val(0, 2) = 0;
- for(unsigned int i = 0; i < nFun; i++){
+ for(size_t i = 0; i < nFun; i++){
val(0, 0) += fun(i, 0) * coef[i];
val(0, 1) += fun(i, 1) * coef[i];
val(0, 2) += fun(i, 2) * coef[i];
diff --git a/FunctionSpace/HexEdgeBasis.cpp b/FunctionSpace/HexEdgeBasis.cpp
index 34f607aab48f4e01ba67df137da5507220448ab6..84383203a7eba4d28f04c0cb2c4edfc2102fbf37 100644
--- a/FunctionSpace/HexEdgeBasis.cpp
+++ b/FunctionSpace/HexEdgeBasis.cpp
@@ -4,7 +4,7 @@
using namespace std;
-HexEdgeBasis::HexEdgeBasis(int order){
+HexEdgeBasis::HexEdgeBasis(size_t order){
/*
// Set Basis Type //
this->order = order;
@@ -180,7 +180,7 @@ HexEdgeBasis::HexEdgeBasis(int order){
for(int l = 1; l < orderPlus; l++){
for(int e = 0; e < 12; e++){
basis[i] =
- new std::vector<Polynomial>((intLegendre[l].compose(liftingSub[e]) * lagrangeSum[e]).gradient());
+ new std::vector<Polynomial>((intLegendre[l].compose(liftingSub[e]) * lagrangeSum[e]).gradient());
i++;
}
@@ -238,11 +238,10 @@ HexEdgeBasis::HexEdgeBasis(int order){
for(int l1 = 1; l1 < orderPlus; l1++){
for(int l2 = 1; l2 < orderPlus; l2++){
for(int f = 0; f < 6; f++){
- basis[i] = new std::vector<Polynomial>((iLegendreXi[l1][f] *
- iLegendreEta[l2][f] *
- lambda[f]).gradient());
-
- i++;
+ basis[i] = new std::vector<Polynomial>((iLegendreXi[l1][f] *
+ iLegendreEta[l2][f] *
+ lambda[f]).gradient());
+ i++;
}
}
}
@@ -252,31 +251,31 @@ HexEdgeBasis::HexEdgeBasis(int order){
for(int l1 = 1; l1 < orderPlus; l1++){
for(int l2 = 1; l2 < orderPlus; l2++){
for(int f = 0; f < 6; f++){
- basis[i] = new std::vector<Polynomial>(3);
+ basis[i] = new std::vector<Polynomial>(3);
- Polynomial tmp1 =
- legendreXi[l1][f] *
- iLegendreEta[l2][f];
+ Polynomial tmp1 =
+ legendreXi[l1][f] *
+ iLegendreEta[l2][f];
- Polynomial tmp2 =
- iLegendreXi[l1][f] *
- legendreEta[l2][f];
+ Polynomial tmp2 =
+ iLegendreXi[l1][f] *
+ legendreEta[l2][f];
- vector<Polynomial> gr1 = grXi[f];
- gr1[0].mul(tmp1);
- gr1[1].mul(tmp1);
- gr1[2].mul(tmp1);
+ vector<Polynomial> gr1 = grXi[f];
+ gr1[0].mul(tmp1);
+ gr1[1].mul(tmp1);
+ gr1[2].mul(tmp1);
- vector<Polynomial> gr2 = grEta[f];
- gr2[0].mul(tmp2);
- gr2[1].mul(tmp2);
- gr2[2].mul(tmp2);
+ vector<Polynomial> gr2 = grEta[f];
+ gr2[0].mul(tmp2);
+ gr2[1].mul(tmp2);
+ gr2[2].mul(tmp2);
- basis[i]->at(0) = (gr1[0] - gr2[0]) * lambda[f];
- basis[i]->at(1) = (gr1[1] - gr2[1]) * lambda[f];
- basis[i]->at(2) = (gr1[2] - gr2[2]) * lambda[f];
+ basis[i]->at(0) = (gr1[0] - gr2[0]) * lambda[f];
+ basis[i]->at(1) = (gr1[1] - gr2[1]) * lambda[f];
+ basis[i]->at(2) = (gr1[2] - gr2[2]) * lambda[f];
- i++;
+ i++;
}
}
}
@@ -338,12 +337,12 @@ HexEdgeBasis::HexEdgeBasis(int order){
for(int l1 = 1; l1 < orderPlus; l1++){
for(int l2 = 1; l2 < orderPlus; l2++){
for(int l3 = 1; l3 < orderPlus; l3++){
- basis[i] = new std::vector<Polynomial>((iLegendreX[l1] *
- iLegendreY[l2] *
- iLegendreZ[l3]).gradient());
+ basis[i] = new std::vector<Polynomial>((iLegendreX[l1] *
+ iLegendreY[l2] *
+ iLegendreZ[l3]).gradient());
- i++;
- cellNumber++;
+ i++;
+ cellNumber++;
}
}
}
diff --git a/FunctionSpace/HexEdgeBasis.h b/FunctionSpace/HexEdgeBasis.h
index 4dd16a9d95e72b072e9710c5ee4af61700384c6b..469a1d824bd80601b50183dd7fd586a563e3c8c4 100644
--- a/FunctionSpace/HexEdgeBasis.h
+++ b/FunctionSpace/HexEdgeBasis.h
@@ -1,7 +1,7 @@
#ifndef _HEXEDGEBASIS_H_
#define _HEXEDGEBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class HexEdgeBasis
@@ -15,12 +15,12 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class HexEdgeBasis: public BasisHierarchical1From{
+class HexEdgeBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
//! Returns a new Edge-Basis for Hexahedra of the given order
- HexEdgeBasis(int order);
+ HexEdgeBasis(size_t order);
//! Deletes this Basis
//!
diff --git a/FunctionSpace/HexNodeBasis.cpp b/FunctionSpace/HexNodeBasis.cpp
index 6bb1691e6366aaad091b167b2366df5d362f39c4..5e418137dab6d07d1cd113b44a7c3c4d62664c2c 100644
--- a/FunctionSpace/HexNodeBasis.cpp
+++ b/FunctionSpace/HexNodeBasis.cpp
@@ -3,7 +3,7 @@
using namespace std;
-HexNodeBasis::HexNodeBasis(int order){
+HexNodeBasis::HexNodeBasis(size_t order){
/*
// Set Basis Type //
this->order = order;
@@ -36,10 +36,10 @@ HexNodeBasis::HexNodeBasis(int order){
const int edgeV[2][12][2] =
{
{ {0, 1}, {0, 3}, {0, 4}, {1, 2}, {1, 5}, {2, 3},
- {2, 6}, {3, 7}, {4, 5}, {4, 7}, {5, 6}, {6, 7} },
+ {2, 6}, {3, 7}, {4, 5}, {4, 7}, {5, 6}, {6, 7} },
{ {1, 0}, {3, 0}, {4, 0}, {2, 1}, {5, 1}, {3, 2},
- {6, 2}, {7, 3}, {5, 4}, {7, 4}, {6, 5}, {7, 6} },
+ {6, 2}, {7, 3}, {5, 4}, {7, 4}, {6, 5}, {7, 6} },
};
const int faceV[6][4] =
@@ -102,43 +102,43 @@ HexNodeBasis::HexNodeBasis(int order){
// Vertex Based (Lagrange) //
(*basis)[0] =
new Polynomial((Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
(*basis)[1] =
new Polynomial((Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
(*basis)[2] =
new Polynomial((Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 1, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
+ (Polynomial(1, 0, 1, 0)) *
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
(*basis)[3] =
new Polynomial((Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 1, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
+ (Polynomial(1, 0, 1, 0)) *
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 0, 1)));
(*basis)[4] =
new Polynomial((Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
- Polynomial(1, 0, 0, 1));
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
+ Polynomial(1, 0, 0, 1));
(*basis)[5] =
new Polynomial((Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
- Polynomial(1, 0, 0, 1));
+ (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0)) *
+ Polynomial(1, 0, 0, 1));
(*basis)[6] =
new Polynomial((Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 1, 0)) *
- Polynomial(1, 0, 0, 1));
+ (Polynomial(1, 0, 1, 0)) *
+ Polynomial(1, 0, 0, 1));
(*basis)[7] =
new Polynomial((Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
- (Polynomial(1, 0, 1, 0)) *
- Polynomial(1, 0, 0, 1));
+ (Polynomial(1, 0, 1, 0)) *
+ Polynomial(1, 0, 0, 1));
// Edge Based //
@@ -152,8 +152,8 @@ HexNodeBasis::HexNodeBasis(int order){
for(int l = 1; l < order; l++){
for(int e = 0; e < 12; e++){
(*basis)[i] = new Polynomial(
- legendre[l].compose(lifting[edge1[e]] - lifting[edge2[e]]) *
- (*(*basis)[edge1[e]] + *(*basis)[edge2[e]]));
+ legendre[l].compose(lifting[edge1[e]] - lifting[edge2[e]]) *
+ (*(*basis)[edge1[e]] + *(*basis)[edge2[e]]));
i++;
}
@@ -188,12 +188,12 @@ HexNodeBasis::HexNodeBasis(int order){
for(int l1 = 1; l1 < order; l1++){
for(int l2 = 1; l2 < order; l2++){
for(int f = 0; f < 6; f++){
- (*basis)[i] = new Polynomial(
- legendre[l1].compose(xi[f]) *
- legendre[l2].compose(eta[f]) *
- lambda[f]);
+ (*basis)[i] = new Polynomial(
+ legendre[l1].compose(xi[f]) *
+ legendre[l2].compose(eta[f]) *
+ lambda[f]);
- i++;
+ i++;
}
}
}
@@ -211,12 +211,12 @@ HexNodeBasis::HexNodeBasis(int order){
for(int l1 = 1; l1 < order; l1++){
for(int l2 = 1; l2 < order; l2++){
for(int l3 = 1; l3 < order; l3++){
- (*basis)[i] =
- new Polynomial(legendre[l1].compose(px) *
- legendre[l2].compose(py) *
- legendre[l3].compose(pz));
+ (*basis)[i] =
+ new Polynomial(legendre[l1].compose(px) *
+ legendre[l2].compose(py) *
+ legendre[l3].compose(pz));
- i++;
+ i++;
}
}
}
diff --git a/FunctionSpace/HexNodeBasis.h b/FunctionSpace/HexNodeBasis.h
index 855e28729d97bdfa682c98a7aa9f83cf888f979e..eb8d9feaf7fbc5a3fa2b629412ce2b43a90fa535 100644
--- a/FunctionSpace/HexNodeBasis.h
+++ b/FunctionSpace/HexNodeBasis.h
@@ -1,7 +1,7 @@
#ifndef _HEXNODEBASIS_H_
#define _HEXNODEBASIS_H_
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
/**
@class HexNodeBasis
@@ -15,12 +15,12 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class HexNodeBasis: public BasisHierarchical0From{
+class HexNodeBasis: public BasisHierarchical0Form{
public:
//! @param order The order of the Basis
//!
//! Returns a new Node-Basis for Hexahedra of the given order
- HexNodeBasis(int order);
+ HexNodeBasis(size_t order);
//! @return Deletes this Basis
//!
diff --git a/FunctionSpace/Legendre.cpp b/FunctionSpace/Legendre.cpp
index a4e7f72620511fa1763bb3cd524548150e692abe..583a52b47b4506be476f3eae8caf04473c740958 100644
--- a/FunctionSpace/Legendre.cpp
+++ b/FunctionSpace/Legendre.cpp
@@ -1,15 +1,15 @@
#include "Legendre.h"
-Polynomial Legendre::legendre(const int n, const Polynomial& l,
- const Polynomial& lMinus){
+Polynomial Legendre::legendre(int n, const Polynomial& l,
+ const Polynomial& lMinus){
const double nPlus = n + 1;
return
l * Polynomial(1, 1, 0, 0) * ((2 * n + 1) / nPlus) - lMinus * (n / nPlus);
}
-Polynomial Legendre::scaled(const int n, const Polynomial& l,
- const Polynomial& lMinus){
+Polynomial Legendre::scaled(int n, const Polynomial& l,
+ const Polynomial& lMinus){
const double nPlus = n + 1;
return
@@ -17,16 +17,17 @@ Polynomial Legendre::scaled(const int n, const Polynomial& l,
lMinus * Polynomial(1, 0, 2, 0) * (( n ) / nPlus);
}
-Polynomial Legendre::integrated(const int n, const Polynomial& l,
- const Polynomial& lMinus){
+Polynomial Legendre::integrated(int n, const Polynomial& l,
+ const Polynomial& lMinus){
const double nPlus = n + 1;
return
- l * Polynomial(1, 1, 0, 0) * ((2 * n - 1) / nPlus) - lMinus * ((n - 2) / nPlus);
+ l * Polynomial(1, 1, 0, 0) * ((2 * n - 1) / nPlus) -
+ lMinus * ((n - 2) / nPlus);
}
-Polynomial Legendre::intScaled(const int n, const Polynomial& l,
- const Polynomial& lMinus){
+Polynomial Legendre::intScaled(int n, const Polynomial& l,
+ const Polynomial& lMinus){
const double nPlus = n + 1;
return
@@ -36,10 +37,11 @@ Polynomial Legendre::intScaled(const int n, const Polynomial& l,
-void Legendre::legendre(Polynomial* polynomial, const int order){
+void Legendre::legendre(Polynomial* polynomial, int order){
int i, j, k;
if(order >= 0)
+
polynomial[0] = Polynomial(1, 0, 0, 0);
if(order >= 1)
@@ -55,7 +57,7 @@ void Legendre::legendre(Polynomial* polynomial, const int order){
}
}
-void Legendre::integrated(Polynomial* polynomial, const int order){
+void Legendre::integrated(Polynomial* polynomial, int order){
int i, j, k;
if(order >= 1)
@@ -74,7 +76,7 @@ void Legendre::integrated(Polynomial* polynomial, const int order){
}
}
-void Legendre::scaled(Polynomial* polynomial, const int order){
+void Legendre::scaled(Polynomial* polynomial, int order){
int i, j, k;
if(order >= 0)
@@ -93,7 +95,7 @@ void Legendre::scaled(Polynomial* polynomial, const int order){
}
}
-void Legendre::intScaled(Polynomial* polynomial, const int order){
+void Legendre::intScaled(Polynomial* polynomial, int order){
int i, j, k;
if(order >= 1)
@@ -111,53 +113,3 @@ void Legendre::intScaled(Polynomial* polynomial, const int order){
}
}
}
-
-/*
-#include <iostream>
-int main(void){
- Polynomial p[13];
- Legendre::legendre(p, 12);
-
- for(int i = 0; i < 13; i++)
- std::cout << "l(" << i << ")= " << (p[i]).toString() << std::endl;
-
-
- std::cout << std::endl;
-
- Polynomial pi[12];
- Legendre::integrated(pi, 12);
-
- for(int i = 0; i < 12; i++)
- std::cout << "L(" << i + 1 << ")= " << pi[i].toString() << std::endl;
-
-
- std::cout << std::endl;
-
- Polynomial ps[13];
- Legendre::scaled(ps, 12);
-
- for(int i = 0; i < 13; i++)
- std::cout << "ls(" << i << ")= " << (ps[i]).toString() << std::endl;
-
-
- std::cout << std::endl;
-
- Polynomial pis[12];
- Legendre::intScaled(pis, 12);
-
- for(int i = 0; i < 12; i++)
- std::cout << "Ls(" << i + 1<< ")= " << (pis[i]).toString() << std::endl;
-
-
- Polynomial p1 = Polynomial(1, 1, 1, 0);// - Polynomial(1, 0, 0, 0);
- Polynomial p2 = Polynomial(1, 0, 1, 1);// - Polynomial(1, 0, 0, 0);
-
- Polynomial p3 = pis[11].compose(p1, p2);
-
- std::cout << std::endl << "p1 = " << p1.toString() << std::endl;
- std::cout << "p2 = " << p2.toString() << std::endl;
- std::cout << "Ls(12, p1, p2) = " << p3.toString() << std::endl;
-
- return 0;
-}
-*/
diff --git a/FunctionSpace/Legendre.h b/FunctionSpace/Legendre.h
index 25924558f094f6cc74e3e3dc9e218962f6286c86..be9b3f8f205edadd7067e52c730e2ad2c3113e38 100644
--- a/FunctionSpace/Legendre.h
+++ b/FunctionSpace/Legendre.h
@@ -22,52 +22,52 @@
class Legendre{
public:
- static void legendre(Polynomial* polynomial, const int order);
- static void integrated(Polynomial* polynomial, const int order);
- static void scaled(Polynomial* polynomial, const int order);
- static void intScaled(Polynomial* polynomial, const int order);
+ static void legendre(Polynomial* polynomial, int order);
+ static void integrated(Polynomial* polynomial, int order);
+ static void scaled(Polynomial* polynomial, int order);
+ static void intScaled(Polynomial* polynomial,int order);
private:
- static Polynomial legendre(const int n,
- const Polynomial& l,
- const Polynomial& lMinus);
+ static Polynomial legendre(int n,
+ const Polynomial& l,
+ const Polynomial& lMinus);
- static Polynomial integrated(const int n,
- const Polynomial& l,
- const Polynomial& lMinus);
+ static Polynomial integrated(int n,
+ const Polynomial& l,
+ const Polynomial& lMinus);
- static Polynomial scaled(const int n,
- const Polynomial& l,
- const Polynomial& lMinus);
+ static Polynomial scaled(int n,
+ const Polynomial& l,
+ const Polynomial& lMinus);
- static Polynomial intScaled(const int n,
- const Polynomial& l,
- const Polynomial& lMinus);
+ static Polynomial intScaled(int n,
+ const Polynomial& l,
+ const Polynomial& lMinus);
};
/**
- @fn void Legendre::legendre(Polynomial*, const int)
+ @fn void Legendre::legendre(Polynomial*, int)
@param polynomial An @em allocated array (of size @c 'order' @c + @c 1)
for storing the requested legendre Polynomial%s
@param order The @em maximal order of the requested Polynomial%s
@return Stores in @c 'polynomial' all the @em classical legendre Polynomial%s
of order [@c 0, @c 'order']
- @fn void Legendre::integrated(Polynomial*, const int)
+ @fn void Legendre::integrated(Polynomial*, int)
@param polynomial An @em allocated array (of size @c 'order')
for storing the requested legendre Polynomial%s
@param order The @em maximal order of the requested Polynomial%s
@return Stores in @c 'polynomial' all the @em integrated legendre Polynomial%s
of order [@c 1, @c 'order']
- @fn void Legendre::scaled(Polynomial*, const int)
+ @fn void Legendre::scaled(Polynomial*, int)
@param polynomial An @em allocated array (of size @c 'order' @c + @c 1)
for storing the requested legendre Polynomial%s
@param order The @em maximal order of the requested Polynomial%s
@return Stores in @c 'polynomial' all the @em scaled legendre Polynomial%s
of order [@c 0, @c 'order']
- @fn void Legendre::intScaled(Polynomial*, const int)
+ @fn void Legendre::intScaled(Polynomial*, int)
@param polynomial An @em allocated array (of size @c 'order')
for storing the requested legendre Polynomial%s
@param order The @em maximal order of the requested Polynomial%s
diff --git a/FunctionSpace/LineEdgeBasis.h b/FunctionSpace/LineEdgeBasis.h
index 411730c509264a7b62dd390cbe606f1e84d5dadf..190c28857fbf840f5b5209c328d4778ae8eca860 100644
--- a/FunctionSpace/LineEdgeBasis.h
+++ b/FunctionSpace/LineEdgeBasis.h
@@ -1,7 +1,7 @@
#ifndef _LINEEDGEBASIS_H_
#define _LINEEDGEBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class LineEdgeBasis
@@ -19,7 +19,7 @@
It also uses the following mapping: @f$x = \frac{u + 1}{2}@f$.
*/
-class LineEdgeBasis: public BasisHierarchical1From{
+class LineEdgeBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/LineNedelecBasis.h b/FunctionSpace/LineNedelecBasis.h
index edb4a699e8633ff54335792b50f581b238b132df..91f5042a015b8544212a9a1594f9bf20272938d8 100644
--- a/FunctionSpace/LineNedelecBasis.h
+++ b/FunctionSpace/LineNedelecBasis.h
@@ -1,7 +1,7 @@
#ifndef _LINENEDELECBASIS_H_
#define _LINENEDELECBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class LineNedelecBasis
@@ -11,7 +11,7 @@
for Lines.@n
*/
-class LineNedelecBasis: public BasisHierarchical1From{
+class LineNedelecBasis: public BasisHierarchical1Form{
public:
//! Returns a new Nedelec Basis for Lines
//!
diff --git a/FunctionSpace/LineNodeBasis.h b/FunctionSpace/LineNodeBasis.h
index 6da87b9d878acd36bc5ce223d42db3e55ebbbcd7..cd40b2e1024911a28be808310e66c65928660a4a 100644
--- a/FunctionSpace/LineNodeBasis.h
+++ b/FunctionSpace/LineNodeBasis.h
@@ -1,7 +1,7 @@
#ifndef _LINENODEBASIS_H_
#define _LINENODEBASIS_H_
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
/**
@class LineNodeBasis
@@ -19,7 +19,7 @@
It also uses the following mapping: @f$x = \frac{u + 1}{2}@f$.
*/
-class LineNodeBasis: public BasisHierarchical0From{
+class LineNodeBasis: public BasisHierarchical0Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/Polynomial.cpp b/FunctionSpace/Polynomial.cpp
index c5a3ca8ee24082007b80c26ecca10e752db41547..e120bf25182f5ce3c78e91dfdd8956b770cbed65 100644
--- a/FunctionSpace/Polynomial.cpp
+++ b/FunctionSpace/Polynomial.cpp
@@ -8,9 +8,10 @@ using namespace std;
const char Polynomial::coefName[3] = {'x', 'y', 'z'};
-Polynomial::Polynomial(const double coef, const int powerX,
- const int powerY,
- const int powerZ){
+Polynomial::Polynomial(double coef,
+ int powerX,
+ int powerY,
+ int powerZ){
nMon = 1;
mon = new monomial_t[1];
@@ -35,7 +36,7 @@ Polynomial::~Polynomial(void){
delete[] mon;
}
-void Polynomial::derivative(const int dim){
+void Polynomial::derivative(int dim){
// Take derivative //
for(int i = 0; i < nMon; i++){
mon[i].coef *= mon[i].power[dim];
@@ -143,7 +144,7 @@ Polynomial Polynomial::divergence(const vector<Polynomial>& p){
}
double Polynomial::at
- (const double x, const double y, const double z) const{
+ (double x, double y, double z) const{
double val = 0;
for(int i = 0; i < nMon; i++){
@@ -156,9 +157,9 @@ double Polynomial::at
}
fullVector<double> Polynomial::at(const vector<Polynomial>& P,
- const double x,
- const double y,
- const double z){
+ double x,
+ double y,
+ double z){
fullVector<double> val(3);
val(0) = P[0].at(x, y, z);
@@ -198,7 +199,7 @@ Polynomial Polynomial::operator*(const Polynomial& other) const{
return newP;
}
-Polynomial Polynomial::operator*(const double alpha) const{
+Polynomial Polynomial::operator*(double alpha) const{
Polynomial newP;
newP.mon = copyMonomial(mon, nMon);
@@ -238,12 +239,12 @@ void Polynomial::mul(const Polynomial& other){
delete[] tmp;
}
-void Polynomial::mul(const double alpha){
+void Polynomial::mul(double alpha){
for(int i = 0; i < nMon; i++)
mon[i].coef *= alpha;
}
-void Polynomial::power(const int n){
+void Polynomial::power(int n){
if (n < 0)
return;
@@ -279,7 +280,7 @@ Polynomial Polynomial::compose(const Polynomial& other) const{
}
Polynomial Polynomial::compose(const Polynomial& otherA,
- const Polynomial& otherB) const{
+ const Polynomial& otherB) const{
stack<monomial_t> stk;
for(int i = 0; i < nMon; i++)
@@ -296,7 +297,8 @@ void Polynomial::operator=(const Polynomial& other){
mon = copyMonomial(other.mon, nMon);
}
-string Polynomial::toString(const Polynomial::monomial_t* mon, const bool isAbs){
+string Polynomial::
+toString(const Polynomial::monomial_t* mon, const bool isAbs){
stringstream stream;
const bool minusOne = mon->coef == -1.0;
const bool notUnitCoef = mon->coef != 1.0 && !minusOne;
@@ -325,12 +327,12 @@ string Polynomial::toString(const Polynomial::monomial_t* mon, const bool isAbs)
// If we have a non zero power, we display it
if(mon->power[i]){
if(notUnitCoef || notOnce)
- stream << " * ";
+ stream << " * ";
stream << coefName[i];
if(mon->power[i] != 1)
- stream << "^" << mon->power[i];
+ stream << "^" << mon->power[i];
notOnce = true;
}
@@ -363,7 +365,7 @@ string Polynomial::toString(void) const{
}
bool Polynomial::isSmaller(const Polynomial::monomial_t* a,
- const Polynomial::monomial_t* b){
+ const Polynomial::monomial_t* b){
// GRevLex order:
// http://www.math.uiuc.edu/Macaulay2/doc/Macaulay2-1.4/share/doc/Macaulay2/Macaulay2Doc/html/___G__Rev__Lex.html
@@ -379,7 +381,7 @@ bool Polynomial::isSmaller(const Polynomial::monomial_t* a,
for(int i = 0; i < 3; i++)
if(dif[i])
- last = dif[i];
+ last = dif[i];
if(last < 0)
return true;
@@ -391,23 +393,23 @@ bool Polynomial::isSmaller(const Polynomial::monomial_t* a,
return false;
}
-void Polynomial::sort(monomial_t* mon, const int size){
+void Polynomial::sort(monomial_t* mon, int size){
for(int i = 0; i < size; i++)
for(int j = i; j < size; j++)
if(isSmaller(&mon[j], &mon[i]))
swap(mon, i, j);
}
-void Polynomial::swap(monomial_t* mon, const int i, const int j){
+void Polynomial::swap(monomial_t* mon, int i, int j){
monomial_t tmp = mon[i];
mon[i] = mon[j];
mon[j] = tmp;
}
-int Polynomial::mergeMon(monomial_t* sourceA, const int sizeA,
- monomial_t* sourceB, const int sizeB,
- monomial_t** dest){
+int Polynomial::mergeMon(monomial_t* sourceA, int sizeA,
+ monomial_t* sourceB, int sizeB,
+ monomial_t** dest){
stack<monomial_t> s;
monomial_t tmp;
@@ -427,8 +429,8 @@ int Polynomial::mergeMon(monomial_t* sourceA, const int sizeA,
tmp.coef += sourceB[j].coef;
if(tmp.coef != 0.0){
- s.push(tmp);
- N++;
+ s.push(tmp);
+ N++;
}
i++;
@@ -477,9 +479,9 @@ int Polynomial::mergeMon(monomial_t* sourceA, const int sizeA,
return N;
}
-int Polynomial::mult(const monomial_t* sourceA, const int sizeA,
- const monomial_t* sourceB, const int sizeB,
- monomial_t** dest){
+int Polynomial::mult(const monomial_t* sourceA, int sizeA,
+ const monomial_t* sourceB, int sizeB,
+ monomial_t** dest){
const monomial_t* a; // smaller polynomial
const monomial_t* b; // bigger polynomial
@@ -524,8 +526,8 @@ int Polynomial::mult(const monomial_t* sourceA, const int sizeA,
tmp[j] = dist[0];
finalSize = mergeMon(dist[0], finalSize,
- dist[i], size,
- &dist[0]);
+ dist[i], size,
+ &dist[0]);
}
// Keep distributed polynomial //
@@ -543,13 +545,13 @@ int Polynomial::mult(const monomial_t* sourceA, const int sizeA,
return finalSize;
}
-void Polynomial::mult(monomial_t* source, const int size, const double alpha){
+void Polynomial::mult(monomial_t* source, int size, double alpha){
for(int i = 0; i < size; i++)
source[i].coef *= alpha;
}
-void Polynomial::distribute(monomial_t* src, const int size, const monomial_t* m){
+void Polynomial::distribute(monomial_t* src, int size, const monomial_t* m){
for(int i = 0; i < size; i++){
src[i].coef *= m->coef;
@@ -560,8 +562,8 @@ void Polynomial::distribute(monomial_t* src, const int size, const monomial_t* m
}
void Polynomial::compose(const Polynomial::monomial_t* src,
- Polynomial comp,
- stack<Polynomial::monomial_t>* stk){
+ Polynomial comp,
+ stack<Polynomial::monomial_t>* stk){
comp.power(src->power[0]);
comp.mul(src->coef);
@@ -580,8 +582,8 @@ void Polynomial::compose(const Polynomial::monomial_t* src,
}
void Polynomial::compose(const Polynomial::monomial_t* src,
- Polynomial compA, Polynomial compB,
- stack<Polynomial::monomial_t>* stk){
+ Polynomial compA, Polynomial compB,
+ stack<Polynomial::monomial_t>* stk){
compA.power(src->power[0]);
compB.power(src->power[1]);
@@ -601,7 +603,8 @@ void Polynomial::compose(const Polynomial::monomial_t* src,
}
}
-Polynomial Polynomial::polynomialFromStack(std::stack<Polynomial::monomial_t>& stk){
+Polynomial Polynomial::
+polynomialFromStack(std::stack<Polynomial::monomial_t>& stk){
Polynomial newP;
monomial_t* tmp;
monomial_t* newMon;
@@ -633,7 +636,8 @@ Polynomial Polynomial::polynomialFromStack(std::stack<Polynomial::monomial_t>& s
return newP;
}
-Polynomial::monomial_t* Polynomial::copyMonomial(const monomial_t* src, const int size){
+Polynomial::monomial_t* Polynomial::copyMonomial(const monomial_t* src,
+ int size){
monomial_t* dest = new monomial_t[size];
for(int i = 0; i < size; i++){
@@ -667,104 +671,3 @@ Polynomial::monomial_t* Polynomial::unitPolynomial(void){
return unit;
}
-
-
-
-
-
-
-
-/*
-#include <iostream>
-int main(void){
- Polynomial m0(-1 , 0, 0, 0);
- Polynomial m1(4.2, 1, 0, 0);
- Polynomial m2(4.2, 1, 1, 0);
- Polynomial m3(4.2, 1, 0, 1);
-
- cout << "m0 = " << m0.toString() << endl;
- cout << "m1 = " << m1.toString() << endl;
- cout << "m1(4, 5, 6) = " << m1.at(4, 5, 6) << endl;
- cout << "m2 = " << m2.toString() << endl;
- cout << "m3 = " << m3.toString() << endl;
-
- Polynomial p0 = m1 + m0;
- Polynomial p1 = m3 + m3;
- Polynomial p2 = p1 + p0;
-
- cout << "p0 = " << p0.toString() << endl;
- cout << "p1 = " << p1.toString() << endl;
- cout << "p2 = " << p2.toString() << endl;
- cout << "p2(1.1, 2.2, 3.3) = " << p2.at(1.1, 2.2, 3.3) << endl;
-
- p2.add(p0);
- cout << "p2 = " << p2.toString() << endl;
-
-
- Polynomial p3 = p2 * p0;
- Polynomial p4 = p3 * p3;
- cout << "p3 = " << p3.toString() << endl;
- cout << "p4 = " << p4.toString() << endl;
-
- p3.mul(p3);
- cout << "p3 = " << p3.toString() << endl;
-
- Polynomial p5 = p2 - p3;
- Polynomial p6 = p3 - p2;
- Polynomial p7 = p6 - p6;
- cout << "p5 = " << p5.toString() << endl;
- cout << "p6 = " << p6.toString() << endl;
- cout << "p7 = " << p7.toString() << endl;
-
- p6.sub(p6);
- cout << "p6 = " << p6.toString() << endl;
-
-
- Polynomial p8(p4);
- Polynomial p9(p4);
- Polynomial p10(p4);
-
- p8.derivative(0);
- p9.derivative(1);
- p10.derivative(2);
-
- cout << "p8 = " << p8.toString() << endl;
- cout << "p9 = " << p9.toString() << endl;
- cout << "p10 = " << p10.toString() << endl;
-
- Polynomial p11 = p8 * 4;
- cout << "p11 = " << p11.toString() << endl;
- cout << "p11(1, 2, 3) = " << p11.at(1, 2, 3.1) << endl;
-
- Polynomial m4(1, 1, 0, 0);
- Polynomial m5(1, 0, 1, 0);
- Polynomial m6(1, 0, 0, 1);
-
- Polynomial p12 = m4 + m5 + m6;
-
- cout << "p12 = " << p12.toString() << endl;
-
- p12.power(4);
- cout << "p12^4 = " << p12.toString() << endl;
-
- Polynomial m7(1, 1, 0, 0);
- Polynomial m8(2, 2, 0, 0);
- Polynomial m9(3, 3, 0, 0);
-
- Polynomial p13 = m9 + m7;
- cout << "p13 = " << p13.toString() << endl;
-
- Polynomial m10(1, 1, 1, 0);
- Polynomial m11(2, 2, 1, 2);
- Polynomial m12(1, 1, 3, 1);
-
- Polynomial p14 = m10 + m11 + m12;
- cout << "p14 = " << p14.toString() << endl;
-
- Polynomial p15 = p14.compose(p13);
- cout << "p15 = p14(p13) = " << p15.toString() << endl;
-
- return 0;
-}
-
-*/
diff --git a/FunctionSpace/Polynomial.h b/FunctionSpace/Polynomial.h
index ba52b8e75eef2cafb9ba259d7665884d151d69f2..b09500d2455e08fedd5a9ff9edd89d8e6e46a988 100644
--- a/FunctionSpace/Polynomial.h
+++ b/FunctionSpace/Polynomial.h
@@ -28,45 +28,46 @@ class Polynomial{
monomial_t* mon;
public:
- Polynomial(const double coef, const int powerX,
- const int powerY,
- const int powerZ);
+ Polynomial(double coef,
+ int powerX,
+ int powerY,
+ int powerZ);
Polynomial(const Polynomial& other);
Polynomial(void);
~Polynomial(void);
- void derivative(const int dim);
+ void derivative(int dim);
std::vector<Polynomial> gradient(void) const;
static std::vector<Polynomial> curl(const std::vector<Polynomial>& p);
static Polynomial divergence(const std::vector<Polynomial>& p);
double operator()
- (const double x, const double y, const double z) const;
+ (double x, double y, double z) const;
double at
- (const double x, const double y, const double z) const;
+ (double x, double y, double z) const;
static fullVector<double> at(const std::vector<Polynomial>& P,
- const double x,
- const double y,
- const double z);
+ double x,
+ double y,
+ double z);
Polynomial operator+(const Polynomial& other) const;
Polynomial operator-(const Polynomial& other) const;
Polynomial operator*(const Polynomial& other) const;
- Polynomial operator*(const double alpha) const;
+ Polynomial operator*(double alpha) const;
void add(const Polynomial& other);
void sub(const Polynomial& other);
void mul(const Polynomial& other);
- void mul(const double alpha);
+ void mul(double alpha);
- void power(const int n);
+ void power(int n);
Polynomial compose(const Polynomial& other) const;
Polynomial compose(const Polynomial& otherA,
- const Polynomial& otherB) const;
+ const Polynomial& otherB) const;
void operator=(const Polynomial& other);
@@ -80,39 +81,39 @@ class Polynomial{
static bool isSmallerPower(const monomial_t* a, const monomial_t* b);
static bool isEqualPower(const monomial_t* a, const monomial_t* b);
- static void sort(monomial_t* mon, const int size);
- static void swap(monomial_t* mon, const int i, const int j);
+ static void sort(monomial_t* mon, int size);
+ static void swap(monomial_t* mon, int i, int j);
- static int mergeMon(monomial_t* sourceA, const int sizeA,
- monomial_t* sourceB, const int sizeB,
- monomial_t** dest);
+ static int mergeMon(monomial_t* sourceA, int sizeA,
+ monomial_t* sourceB, int sizeB,
+ monomial_t** dest);
- static int mult(const monomial_t* sourceA, const int sizeA,
- const monomial_t* sourceB, const int sizeB,
- monomial_t** dest);
+ static int mult(const monomial_t* sourceA, int sizeA,
+ const monomial_t* sourceB, int sizeB,
+ monomial_t** dest);
- static void mult(monomial_t* source, const int size, const double alpha);
+ static void mult(monomial_t* source, int size, double alpha);
- static void distribute(monomial_t* src, const int size, const monomial_t* m);
+ static void distribute(monomial_t* src, int size, const monomial_t* m);
static void compose(const monomial_t* src,
- Polynomial comp,
- std::stack<monomial_t>* stk);
+ Polynomial comp,
+ std::stack<monomial_t>* stk);
static void compose(const monomial_t* src,
- Polynomial compA, Polynomial compB,
- std::stack<monomial_t>* stk);
+ Polynomial compA, Polynomial compB,
+ std::stack<monomial_t>* stk);
static Polynomial polynomialFromStack(std::stack<monomial_t>& stk);
- static monomial_t* copyMonomial(const monomial_t* src, const int size);
+ static monomial_t* copyMonomial(const monomial_t* src, int size);
static monomial_t* zeroPolynomial(void);
static monomial_t* unitPolynomial(void);
};
/**
- @fn Polynomial::Polynomial(const double, const int, const int, const int)
+ @fn Polynomial::Polynomial(double, int, int, int)
@param coef The coeficient of the futur monomial
@param powerX The power of the '@c x' coordinate
of the futur monomial
@@ -177,7 +178,7 @@ class Polynomial{
vector of Polynomial%s
**
- @fn double Polynomial::operator()(const double, const double, const double)
+ @fn double Polynomial::operator()(double, double, double)
@param x A value
@param y A value
@param z A value
@@ -185,7 +186,7 @@ class Polynomial{
Polynomial at (@c x, @c y, @c z)
**
- @fn double Polynomial::at(const double, const double, const double) const
+ @fn double Polynomial::at(double, double, double) const
@param x A value
@param y A value
@param z A value
@@ -193,7 +194,7 @@ class Polynomial{
Polynomial at (@c x, @c y, @c z)
**
- @fn fullVector<double> Polynomial::at(const std::vector<Polynomial>&, const double, const double, const double)
+ @fn fullVector<double> Polynomial::at(const std::vector<Polynomial>&, double, double, double)
@param P A vector of Polynomial%s
@param x A value
@param y A value
@@ -220,7 +221,7 @@ class Polynomial{
@em product of this Polynomial and the given one
**
- @fn Polynomial Polynomial::operator*(const double) const
+ @fn Polynomial Polynomial::operator*(double) const
@param alpha A value
@return Returns a @em new Polynomial,
which is this Polynomial @em multiplied by @c alpha
@@ -253,7 +254,7 @@ class Polynomial{
this Polynomial
**
- @fn void Polynomial::mul(const double)
+ @fn void Polynomial::mul(double)
@param alpha A value
@return This Polynomial is @em multiplied
by the given value
@@ -301,21 +302,21 @@ class Polynomial{
// Inline Functions //
//////////////////////
-inline double Polynomial::operator() (const double x,
- const double y,
- const double z) const{
+inline double Polynomial::operator() (double x,
+ double y,
+ double z) const{
return at(x, y, z);
}
inline bool Polynomial::isEqual(const Polynomial::monomial_t* a,
- const Polynomial::monomial_t* b){
+ const Polynomial::monomial_t* b){
return a->power[0] == b->power[0] &&
a->power[1] == b->power[1] &&
a->power[2] == b->power[2];
}
inline bool Polynomial::isSmallerPower(const Polynomial::monomial_t* a,
- const Polynomial::monomial_t* b){
+ const Polynomial::monomial_t* b){
return
a->power[0] + a->power[1] + a->power[2]
@@ -324,7 +325,7 @@ inline bool Polynomial::isSmallerPower(const Polynomial::monomial_t* a,
}
inline bool Polynomial::isEqualPower(const Polynomial::monomial_t* a,
- const Polynomial::monomial_t* b){
+ const Polynomial::monomial_t* b){
return
a->power[0] + a->power[1] + a->power[2]
diff --git a/FunctionSpace/QuadEdgeBasis.cpp b/FunctionSpace/QuadEdgeBasis.cpp
index c4dc7d49295e01d9f2024119db36b32baa735514..8daf138f48d3fb0471cf4a348fedcf2c76e2cf5a 100644
--- a/FunctionSpace/QuadEdgeBasis.cpp
+++ b/FunctionSpace/QuadEdgeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
QuadEdgeBasis::QuadEdgeBasis(size_t order){
// Reference Space //
refSpace = new QuadReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -241,6 +241,8 @@ QuadEdgeBasis::QuadEdgeBasis(size_t order){
}
QuadEdgeBasis::~QuadEdgeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/QuadEdgeBasis.h b/FunctionSpace/QuadEdgeBasis.h
index 95d6edb66df94702b9afc9bcc7f52cbdac62f566..280666d8ddafb5840d488c32eddd8c1e75127f49 100644
--- a/FunctionSpace/QuadEdgeBasis.h
+++ b/FunctionSpace/QuadEdgeBasis.h
@@ -1,7 +1,7 @@
#ifndef _QUADEDGEBASIS_H_
#define _QUADEDGEBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class QuadEdgeBasis
@@ -19,7 +19,7 @@
@li @f$y = \frac{v + 1}{2}@f$
*/
-class QuadEdgeBasis: public BasisHierarchical1From{
+class QuadEdgeBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/QuadNedelecBasis.cpp b/FunctionSpace/QuadNedelecBasis.cpp
index a91c2e4de14f27e85afb6eae424f8c9010f504b9..f3b6c891465f54567c9eb1f6e3778d862d3f9c2b 100644
--- a/FunctionSpace/QuadNedelecBasis.cpp
+++ b/FunctionSpace/QuadNedelecBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
QuadNedelecBasis::QuadNedelecBasis(void){
// Reference Space //
refSpace = new QuadReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -108,6 +108,8 @@ QuadNedelecBasis::QuadNedelecBasis(void){
}
QuadNedelecBasis::~QuadNedelecBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/QuadNedelecBasis.h b/FunctionSpace/QuadNedelecBasis.h
index e429a895724d454ee2ebbb4a7394c26a16d9d7f9..77194bc45ff91279e049c47d71581332488bc239 100644
--- a/FunctionSpace/QuadNedelecBasis.h
+++ b/FunctionSpace/QuadNedelecBasis.h
@@ -1,7 +1,7 @@
#ifndef _QUADNEDELECBASIS_H_
#define _QUADNEDELECBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class QuadNedelecBasis
@@ -11,7 +11,7 @@
for Quadrangles.@n
*/
-class QuadNedelecBasis: public BasisHierarchical1From{
+class QuadNedelecBasis: public BasisHierarchical1Form{
public:
//! Returns a new Nedelec Basis for Quadrangles
//!
diff --git a/FunctionSpace/QuadNodeBasis.cpp b/FunctionSpace/QuadNodeBasis.cpp
index f75cdb87f6058ce8bff258299f3f250b59aa7d37..009af96233c3d0bb55ee3a98788dc3532cc37aeb 100644
--- a/FunctionSpace/QuadNodeBasis.cpp
+++ b/FunctionSpace/QuadNodeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
QuadNodeBasis::QuadNodeBasis(size_t order){
// Reference Space //
refSpace = new QuadReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -145,6 +145,8 @@ QuadNodeBasis::QuadNodeBasis(size_t order){
}
QuadNodeBasis::~QuadNodeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/QuadNodeBasis.h b/FunctionSpace/QuadNodeBasis.h
index 96c69c6d6e231a81d7b7093001d72bc0bea23a75..6122841ec4006a4cc71f61fc7229bcab1e7d820c 100644
--- a/FunctionSpace/QuadNodeBasis.h
+++ b/FunctionSpace/QuadNodeBasis.h
@@ -1,7 +1,7 @@
#ifndef _QUADNODEBASIS_H_
#define _QUADNODEBASIS_H_
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
/**
@class QuadNodeBasis
@@ -19,7 +19,7 @@
@li @f$y = \frac{v + 1}{2}@f$
*/
-class QuadNodeBasis: public BasisHierarchical0From{
+class QuadNodeBasis: public BasisHierarchical0Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/ReferenceSpaceLagrange.cpp b/FunctionSpace/ReferenceSpaceLagrange.cpp
index 932ec9ce4cd35c52566a839cee7a434a0ef88056..6c088a3027ce3ba3c962881d35fa026f042fdc88 100644
--- a/FunctionSpace/ReferenceSpaceLagrange.cpp
+++ b/FunctionSpace/ReferenceSpaceLagrange.cpp
@@ -25,20 +25,20 @@ void ReferenceSpaceLagrange::getLagrangeNode(void){
const size_t nPerm = pTree->getNPermutation();
// Alloc //
- vector<unsigned int>* tmp;
- node = new vector<const vector<unsigned int>*>(nPerm);
+ vector<size_t>* tmp;
+ node = new vector<const vector<size_t>*>(nPerm);
// Populate //
- for(unsigned int p = 0; p < nPerm; p++){
+ for(size_t p = 0; p < nPerm; p++){
// Alloc Temp //
- tmp = new vector<unsigned int>(nNode);
+ tmp = new vector<size_t>(nNode);
// Vertex based node
- for(unsigned int i = 0; i < nVertex; i++)
+ for(size_t i = 0; i < nVertex; i++)
(*tmp)[i] = i;
// Edge based node
- for(unsigned int e = 0; e < nEdge; e++)
+ for(size_t e = 0; e < nEdge; e++)
edgeSeq(*tmp,
nVertex + nNodePerEdge * e,
nVertex + nNodePerEdge * e,
@@ -47,7 +47,7 @@ void ReferenceSpaceLagrange::getLagrangeNode(void){
*(*(*edge)[p])[e]);
// Face based node
- for(unsigned int f = 0; f < nFace; f++)
+ for(size_t f = 0; f < nFace; f++)
faceSeq(*tmp,
nVertex + nNodePerEdge * nEdge + nNodePerFace * f,
nVertex + nNodePerEdge * nEdge + nNodePerFace * f,
@@ -62,19 +62,19 @@ void ReferenceSpaceLagrange::getLagrangeNode(void){
*/
}
-void ReferenceSpaceLagrange::edgeSeq(vector<unsigned int>& vec,
- unsigned int startIdx,
- unsigned int startVal,
- unsigned int stopVal,
+void ReferenceSpaceLagrange::edgeSeq(vector<size_t>& vec,
+ size_t startIdx,
+ size_t startVal,
+ size_t stopVal,
size_t* refEdge,
- const vector<unsigned int>& edge){
+ const vector<size_t>& edge){
// Is reverted ? //
const bool isRevert = (edge[0] != refEdge[0]);
// Index //
- unsigned int val = startVal;
- unsigned int idx;
+ size_t val = startVal;
+ size_t idx;
// Depending if edge is reverted ...
if(isRevert)
@@ -95,16 +95,16 @@ void ReferenceSpaceLagrange::edgeSeq(vector<unsigned int>& vec,
}
}
-void ReferenceSpaceLagrange::faceSeq(vector<unsigned int>& vec,
- unsigned int startIdx,
- unsigned int startVal,
- unsigned int stopVal,
- size_t* refFace,
- const vector<unsigned int>& face,
- unsigned int nNodePerEdge){
+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 //
- unsigned int val = startVal;
- unsigned int idx = startIdx;
+ size_t val = startVal;
+ size_t idx = startIdx;
// Populate //
for(; val < stopVal; val++){
@@ -114,19 +114,19 @@ void ReferenceSpaceLagrange::faceSeq(vector<unsigned int>& vec,
}
string ReferenceSpaceLagrange::toString(void) const{
- const size_t nPerm = pTree->getNPermutation();
- const unsigned int nNodeMinus = nNode - 1;
- stringstream stream;
+ const size_t nPerm = pTree->getNPermutation();
+ const size_t nNodeMinus = nNode - 1;
+ stringstream stream;
stream << ReferenceSpace::toString();
stream << "Lagrange Nodes Permutations:" << endl;
- for(unsigned int i = 0; i < nPerm; i++){
+ for(size_t i = 0; i < nPerm; i++){
stream << " * RefSpace #" << i + 1 << ":" << endl
<< " -- [";
- for(unsigned int j = 0; j < nNodeMinus; j++)
+ for(size_t j = 0; j < nNodeMinus; j++)
stream << node->at(i)->at(j) << ", ";
stream << node->at(i)->at(nNodeMinus) << "]" << endl;
diff --git a/FunctionSpace/ReferenceSpaceLagrange.h b/FunctionSpace/ReferenceSpaceLagrange.h
index 92c088018b7430fd22cc5b0ba0b4e76342fbe8be..62f65b42ab2fd6aa0cf86de625a87a93092b690a 100644
--- a/FunctionSpace/ReferenceSpaceLagrange.h
+++ b/FunctionSpace/ReferenceSpaceLagrange.h
@@ -26,17 +26,17 @@
class ReferenceSpaceLagrange: public ReferenceSpace{
protected:
// Lagrange Node Permutation //
- unsigned int nNode;
- unsigned int nNodePerEdge;
- unsigned int nNodePerFace;
- unsigned int nNodePerCell;
+ size_t nNode;
+ size_t nNodePerEdge;
+ size_t nNodePerFace;
+ size_t nNodePerCell;
- std::vector<const std::vector<unsigned int>*>* node;
+ std::vector<const std::vector<size_t>*>* node;
public:
virtual ~ReferenceSpaceLagrange(void);
- const std::vector<const std::vector<unsigned int>*>&
+ const std::vector<const std::vector<size_t>*>&
getAllLagrangeNode(void) const;
virtual std::string toString(void) const;
@@ -46,20 +46,20 @@ class ReferenceSpaceLagrange: public ReferenceSpace{
void getLagrangeNode(void);
- static void edgeSeq(std::vector<unsigned int>& vec,
- unsigned int startIdx,
- unsigned int startVal,
- unsigned int stopVal,
- size_t* refEdge,
- const std::vector<unsigned int>& edge);
-
- static void faceSeq(std::vector<unsigned int>& vec,
- unsigned int startIdx,
- unsigned int startVal,
- unsigned int stopVal,
- size_t* refFace,
- const std::vector<unsigned int>& face,
- unsigned int nNodePerEdge);
+ 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);
};
@@ -68,7 +68,7 @@ class ReferenceSpaceLagrange: public ReferenceSpace{
/////////////////////
inline
-const std::vector<const std::vector<unsigned int>*>&
+const std::vector<const std::vector<size_t>*>&
ReferenceSpaceLagrange::getAllLagrangeNode(void) const{
return *node;
}
diff --git a/FunctionSpace/TetEdgeBasis.cpp b/FunctionSpace/TetEdgeBasis.cpp
index 5d3fd21a79735a6367509414af7aed6b27b3c5e7..cd52ff813c6947caa42b36e1db738f5d41937dbb 100644
--- a/FunctionSpace/TetEdgeBasis.cpp
+++ b/FunctionSpace/TetEdgeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
TetEdgeBasis::TetEdgeBasis(size_t order){
// Reference Space //
refSpace = new TetReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -324,6 +324,8 @@ TetEdgeBasis::TetEdgeBasis(size_t order){
}
TetEdgeBasis::~TetEdgeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TetEdgeBasis.h b/FunctionSpace/TetEdgeBasis.h
index d8e7856fd439513b8aebd0807a5d5c9b3a8e0431..93cdbb4a3a177bb98ef969f6950940b1f246664b 100644
--- a/FunctionSpace/TetEdgeBasis.h
+++ b/FunctionSpace/TetEdgeBasis.h
@@ -1,7 +1,7 @@
#ifndef _TETEDGEBASIS_H_
#define _TETEDGEBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class TetEdgeBasis
@@ -15,7 +15,7 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class TetEdgeBasis: public BasisHierarchical1From{
+class TetEdgeBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/TetNedelecBasis.cpp b/FunctionSpace/TetNedelecBasis.cpp
index 2b06274cb981d6f244e83814ee3b030fe2f21f83..80ec10255544c7f450470ba3eb0ba60d6eda9733 100644
--- a/FunctionSpace/TetNedelecBasis.cpp
+++ b/FunctionSpace/TetNedelecBasis.cpp
@@ -6,7 +6,7 @@ using namespace std;
TetNedelecBasis::TetNedelecBasis(void){
// Reference Space //
refSpace = new TetReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -69,6 +69,8 @@ TetNedelecBasis::TetNedelecBasis(void){
}
TetNedelecBasis::~TetNedelecBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TetNedelecBasis.h b/FunctionSpace/TetNedelecBasis.h
index 900085867d485fa62e72304a3e6c9bcac141212c..151296554cbc386202cf5d5598378ad12e47a04f 100644
--- a/FunctionSpace/TetNedelecBasis.h
+++ b/FunctionSpace/TetNedelecBasis.h
@@ -1,7 +1,7 @@
#ifndef _TETNEDELECBASIS_H_
#define _TETNEDELECBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class TetNedelecBasis
@@ -11,7 +11,7 @@
a Nedelec Basis for Tetrahedra.
*/
-class TetNedelecBasis: public BasisHierarchical1From{
+class TetNedelecBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/TetNodeBasis.cpp b/FunctionSpace/TetNodeBasis.cpp
index c9854688a42b77c605fc85f5d13e87f95b69b88c..512178e09c7a3fe21d8c3b5198a9de2b4a769322 100644
--- a/FunctionSpace/TetNodeBasis.cpp
+++ b/FunctionSpace/TetNodeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
TetNodeBasis::TetNodeBasis(size_t order){
// Reference Space //
refSpace = new TetReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -157,6 +157,8 @@ TetNodeBasis::TetNodeBasis(size_t order){
}
TetNodeBasis::~TetNodeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TetNodeBasis.h b/FunctionSpace/TetNodeBasis.h
index 3eff8cf0754aeb284ef05d259484aa676096b458..8d98b54a85086d71bb766c26532a23c40da7008c 100644
--- a/FunctionSpace/TetNodeBasis.h
+++ b/FunctionSpace/TetNodeBasis.h
@@ -1,7 +1,7 @@
#ifndef _TETNODEBASIS_H_
#define _TETNODEBASIS_H_
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
/**
@class TetNodeBasis
@@ -15,7 +15,7 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class TetNodeBasis: public BasisHierarchical0From{
+class TetNodeBasis: public BasisHierarchical0Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/TriEdgeBasis.cpp b/FunctionSpace/TriEdgeBasis.cpp
index c1faa4c2493231bf219d07bf0b6544a6d75de0e2..70f216683a708ec4465848978428494e6e0e7769 100644
--- a/FunctionSpace/TriEdgeBasis.cpp
+++ b/FunctionSpace/TriEdgeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
TriEdgeBasis::TriEdgeBasis(size_t order){
// Reference Space //
refSpace = new TriReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -237,6 +237,8 @@ TriEdgeBasis::TriEdgeBasis(size_t order){
}
TriEdgeBasis::~TriEdgeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TriEdgeBasis.h b/FunctionSpace/TriEdgeBasis.h
index 99c7a4d08a69555120a9263ef7467beed172e4a4..830d226c3d942ad21dd17d0eb959dd7c6a5a3219 100644
--- a/FunctionSpace/TriEdgeBasis.h
+++ b/FunctionSpace/TriEdgeBasis.h
@@ -1,7 +1,7 @@
#ifndef _TRIEDGEBASIS_H_
#define _TRIEDGEBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class TriEdgeBasis
@@ -15,7 +15,7 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class TriEdgeBasis: public BasisHierarchical1From{
+class TriEdgeBasis: public BasisHierarchical1Form{
public:
//! @param order The order of the Basis
//!
diff --git a/FunctionSpace/TriNedelecBasis.cpp b/FunctionSpace/TriNedelecBasis.cpp
index 7cabff1df297b7e04efa942ea393bb86078e8619..0c8b4965ff4c8fb754840b12bf954cc291e20461 100644
--- a/FunctionSpace/TriNedelecBasis.cpp
+++ b/FunctionSpace/TriNedelecBasis.cpp
@@ -6,7 +6,7 @@ using namespace std;
TriNedelecBasis::TriNedelecBasis(void){
// Reference Space //
refSpace = new TriReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -65,6 +65,8 @@ TriNedelecBasis::TriNedelecBasis(void){
}
TriNedelecBasis::~TriNedelecBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TriNedelecBasis.h b/FunctionSpace/TriNedelecBasis.h
index 078fc325383b8929a2b47dd31703c3015d337d99..772d4cb6f60510713c8da2be4e7adb9429c71934 100644
--- a/FunctionSpace/TriNedelecBasis.h
+++ b/FunctionSpace/TriNedelecBasis.h
@@ -1,7 +1,7 @@
#ifndef _TRINEDELECBASIS_H_
#define _TRINEDELECBASIS_H_
-#include "BasisHierarchical1From.h"
+#include "BasisHierarchical1Form.h"
/**
@class TriNedelecBasis
@@ -11,7 +11,7 @@
for Triangles.@n
*/
-class TriNedelecBasis: public BasisHierarchical1From{
+class TriNedelecBasis: public BasisHierarchical1Form{
public:
//! Returns a new Nedelec Basis for Triangles
//!
diff --git a/FunctionSpace/TriNodeBasis.cpp b/FunctionSpace/TriNodeBasis.cpp
index e5f5890c63107a027a3e8cf0b67c684119101221..5e954a92617e6d49f3a20d926b7866b6e4fe2872 100644
--- a/FunctionSpace/TriNodeBasis.cpp
+++ b/FunctionSpace/TriNodeBasis.cpp
@@ -7,7 +7,7 @@ using namespace std;
TriNodeBasis::TriNodeBasis(size_t order){
// Reference Space //
refSpace = new TriReferenceSpace;
- nRefSpace = refSpace->getNReferenceSpace();
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
const vector<vector<vector<size_t> > >&
edgeIdx = refSpace->getEdgeNodeIndex();
@@ -115,6 +115,8 @@ TriNodeBasis::TriNodeBasis(size_t order){
}
TriNodeBasis::~TriNodeBasis(void){
+ const size_t nRefSpace = getReferenceSpace().getNReferenceSpace();
+
// ReferenceSpace //
delete refSpace;
diff --git a/FunctionSpace/TriNodeBasis.h b/FunctionSpace/TriNodeBasis.h
index 2d1b98d304314ee7871b52a148b213dc4ef6f56f..630fa510b06ccf6b0f792c1394c2cf2ebacd913b 100644
--- a/FunctionSpace/TriNodeBasis.h
+++ b/FunctionSpace/TriNodeBasis.h
@@ -1,7 +1,7 @@
#ifndef _TRINODEBASIS_H_
#define _TRINODEBASIS_H_
-#include "BasisHierarchical0From.h"
+#include "BasisHierarchical0Form.h"
/**
@class TriNodeBasis
@@ -15,7 +15,7 @@
Basis for @em high @em order Polynomial%s generation.@n
*/
-class TriNodeBasis: public BasisHierarchical0From{
+class TriNodeBasis: public BasisHierarchical0Form{
public:
//! @param order The order of the Basis
//!