FunctionSpace::getForm() and FunctionSpace::getOrder()

FunctionSpace/FunctionSpace.cpp

@@ -20,9 +20,7 @@ FunctionSpace::~FunctionSpace(void){
       delete basis[i];
 }
 
-void FunctionSpace::build(GroupOfElement& goe,
-                          size_t order, size_t form, string family){
-
+void FunctionSpace::build(GroupOfElement& goe, string family){
   // Save GroupOfElement & Mesh //
   this->goe  = &goe;
   this->mesh = &(goe.getMesh());

FunctionSpace/FunctionSpace.h

@@ -46,8 +46,10 @@ class FunctionSpace{
   size_t fPerFace;
   size_t fPerCell;
 
-  // Scalar Field ? //
-  bool scalar;
+  // Differential From & Order //
+  bool   scalar;
+  size_t form;
+  size_t order;
 
   // Dofs //
   std::set<Dof>                  dof;
@@ -56,11 +58,14 @@ class FunctionSpace{
  public:
   virtual ~FunctionSpace(void);
 
-  const std::vector<const Basis*>& getBasis(const MElement& element) const;
-  const Basis&                     getBasis(size_t i) const;
+  const Basis& getBasis(const MElement& element) const;
+  const Basis& getBasis(size_t i) const;
 
   GroupOfElement& getSupport(void) const;
-  bool            isScalar(void) const;
+
+  bool   isScalar(void) const;
+  size_t getForm(void)  const;
+  size_t getOrder(void) const;
 
   std::vector<Dof> getUnorderedKeys(const MElement& element) const;
   std::vector<Dof> getKeys(const MElement& element) const;
@@ -72,8 +77,8 @@ class FunctionSpace{
 
  protected:
   FunctionSpace(void);
-  void build(GroupOfElement& goe,
-             size_t order, size_t form, std::string family);
+
+  void build(GroupOfElement& goe, std::string family);
   void buildDof(void);
 };
 
@@ -135,9 +140,8 @@ class FunctionSpace{
 // Inline Functions //
 //////////////////////
 
-inline const std::vector<const Basis*>&
-FunctionSpace::getBasis(const MElement& element) const{
-  return basis;
+inline const Basis& FunctionSpace::getBasis(const MElement& element) const{
+  return *basis[element.getType()];
 }
 
 inline const Basis& FunctionSpace::getBasis(size_t i) const{
@@ -152,6 +156,14 @@ inline bool FunctionSpace::isScalar(void) const{
   return scalar;
 }
 
+inline size_t FunctionSpace::getForm(void) const{
+  return form;
+}
+
+inline size_t FunctionSpace::getOrder(void) const{
+  return order;
+}
+
 inline const std::set<Dof>& FunctionSpace::getAllDofs(void) const{
   return dof;
 }

FunctionSpace/FunctionSpaceScalar.cpp

@@ -2,32 +2,35 @@
 #include "FunctionSpaceScalar.h"
 
 FunctionSpaceScalar::FunctionSpaceScalar(GroupOfElement& goe, size_t order){
-  scalar = true;
-  build(goe, order, 0, "hierarchical");
+  this->scalar = true;
+  this->form   = 0;
+  this->order  = order;
+
+  build(goe, "hierarchical");
 }
 
 FunctionSpaceScalar::FunctionSpaceScalar(GroupOfElement& goe, size_t order,
                                          std::string family){
-  scalar = true;
-  build(goe, order, 0, family);
+  this->scalar = true;
+  this->form   = 0;
+  this->order  = order;
+
+  build(goe, family);
 }
 
 FunctionSpaceScalar::~FunctionSpaceScalar(void){
   // Done by FunctionSpace
 }
 
-double FunctionSpaceScalar::
-interpolateInABC(const MElement& element,
-                 const std::vector<double>& coef,
-                 double abc[3]) const{
-  // Element Type //
-  const int eType = element.getType();
-
+double FunctionSpaceScalar::interpolateInABC(const MElement& element,
+                                             const std::vector<double>& coef,
+                                             double abc[3]) const{
   // Get Basis Functions //
-  const size_t nFun = basis[eType]->getNFunction();
+  const Basis& basis = getBasis(element);
+  const size_t nFun  = basis.getNFunction();
   fullMatrix<double> fun(nFun, 1);
 
-  basis[eType]->getFunctions(fun, element, abc[0], abc[1], abc[2]);
+  basis.getFunctions(fun, element, abc[0], abc[1], abc[2]);
 
   // Interpolate (in Reference Place) //
   double val = 0;
@@ -48,14 +51,12 @@ interpolateDerivativeInABC(const MElement& element,
   ReferenceSpaceManager::getJacobian(element, abc[0], abc[1], abc[2], invJac);
   invJac.invertInPlace();
 
-  // Element Type //
-  const int eType = element.getType();
-
   // Get Basis Functions //
-  const size_t nFun = basis[eType]->getNFunction();
+  const Basis& basis = getBasis(element);
+  const size_t nFun  = basis.getNFunction();
   fullMatrix<double> fun(nFun, 3);
 
-  basis[eType]->getDerivative(fun, element, abc[0], abc[1], abc[2]);
+  basis.getDerivative(fun, element, abc[0], abc[1], abc[2]);
 
   // Interpolate (in Reference Place) //
   fullMatrix<double> val(1, 3);

FunctionSpace/FunctionSpaceVector.cpp

@@ -2,14 +2,20 @@
 #include "FunctionSpaceVector.h"
 
 FunctionSpaceVector::FunctionSpaceVector(GroupOfElement& goe, size_t order){
-  scalar = false;
-  build(goe, order, 1, "hierarchical");
+  this->scalar = false;
+  this->form   = 1;
+  this->order  = order;
+
+  build(goe, "hierarchical");
 }
 
 FunctionSpaceVector::FunctionSpaceVector(GroupOfElement& goe, size_t order,
                                          std::string family){
-  scalar = false;
-  build(goe, order, 1, family);
+  this->scalar = false;
+  this->form   = 1;
+  this->order  = order;
+
+  build(goe, family);
 }
 
 FunctionSpaceVector::~FunctionSpaceVector(void){
@@ -26,14 +32,12 @@ interpolateInABC(const MElement& element,
   ReferenceSpaceManager::getJacobian(element, abc[0], abc[1], abc[2], invJac);
   invJac.invertInPlace();
 
-  // Element Type //
-  const int eType = element.getType();
-
   // Get Basis Functions //
-  const size_t nFun = basis[eType]->getNFunction();
+  const Basis& basis = getBasis(element);
+  const size_t nFun  = basis.getNFunction();
   fullMatrix<double> fun(nFun, 3);
 
-  basis[eType]->getFunctions(fun, element, abc[0], abc[1], abc[2]);
+  basis.getFunctions(fun, element, abc[0], abc[1], abc[2]);
 
   // Interpolate (in Reference Place) //
   fullMatrix<double> val(1, 3);