0Form Interpolation + Beginning 1Form

FunctionSpace/LocalFunctionSpace.h

@@ -13,16 +13,12 @@
    with an Element.
  */
 
-#include "Jacobian.h"
-
 class LocalFunctionSpace{
  protected:
   bool      scalar;
   int       size;
   int       type;
 
-  Jacobian* jac;
-
  public:
   //! Deletes this LocalFunctionSpace
   //!

FunctionSpace/LocalFunctionSpace0Form.cpp

 #include "LocalFunctionSpace0Form.h"
-
+#include "BasisScalar.h"
+#include "fullMatrix.h"
+#include "Exception.h"
 
 LocalFunctionSpace0Form::LocalFunctionSpace0Form(const Basis& basis, 
 						 const Element& elem){
+  if(!basis.isScalar())
+    throw Exception("Can't Create a Scalar Function Space with a Vectorial Basis"); 
+
+  const BasisScalar& b = static_cast<const BasisScalar&>(basis); 
+
+  this->size  = b.getSize(); 
+  this->type  = b.getType();  
+  this->basis = &(b.getBasis());
+
+  jac = &(elem.getJacobian());
 }
 
 
 LocalFunctionSpace0Form::~LocalFunctionSpace0Form(void){
+  // LocalFunctionSpace0From is *NOT* responsible 
+  // for deleting 'basis' 
+  // It's the Basis job 
 }
 
 
 double LocalFunctionSpace0Form::interpolate(const fullVector<double>& coef, 
 					    double x, double y, double z) const{
+  double res = 0;
+
+  for(int i = 0; i < size; i++){
+    fullVector<double> uv = jac->invMap(x, y);
+
+    res += (*basis)[i].at(uv(0), uv(1), 0.0);
+  }
 
+  return res;
 }

FunctionSpace/LocalFunctionSpace0Form.h

 #ifndef _LOCALFUNCTIONSPACE0FORM_H_
 #define _LOCALFUNCTIONSPACE0FORM_H_
 
+#include <vector>
+#include "Polynomial.h"
+#include "Basis.h"
+#include "Element.h"
+#include "Jacobian.h"
+#include "LocalFunctionSpaceScalar.h"
+
 /**
    @class LocalFunctionSpace0Form
    @brief 0 Form Local Function Spaces
@@ -8,15 +15,10 @@
    A Local Function Space build on a @em 0 @em Form
  */
 
-#include <vector>
-#include "Polynomial.h"
-#include "Basis.h"
-#include "Element.h"
-#include "LocalFunctionSpaceScalar.h"
-
 class LocalFunctionSpace0Form: public LocalFunctionSpaceScalar{
  private:
   const std::vector<Polynomial>* basis;
+  Jacobian* jac;  
 
  public:
   //! Instantiate a new LocalFunctionSpace0Form

FunctionSpace/LocalFunctionSpace1Form.cpp

 #include "LocalFunctionSpace1Form.h"
-
+#include "BasisVector.h"
+#include "fullMatrix.h"
+#include "Exception.h"
 
 LocalFunctionSpace1Form::LocalFunctionSpace1Form(const Basis& basis, 
 						 const Element& elem){
+  
+  if(basis.isScalar()) 
+    throw Exception("Can't Create a Vector Function Space with a Scalar Basis"); 
+  
+  const BasisVector& b = static_cast<const BasisVector&>(basis); 
+
+  this->size  = b.getSize(); 
+  this->type  = b.getType();  
+  this->basis = &(b.getBasis());
+
+  jac    = &(elem.getJacobian());
+  orient = &(elem.getAllOrientations());
 }
 
 
 LocalFunctionSpace1Form::~LocalFunctionSpace1Form(void){
+  // LocalFunctionSpace1From is *NOT* responsible 
+  // for deleting 'basis' 
+  // It's the Basis job 
 }
 
 
@@ -14,4 +31,14 @@ fullVector<double> LocalFunctionSpace1Form::
 interpolate(const fullVector<double>& coef, 
 	    double x, double y, double z) const{
 
+  //double res = 0;
+  
+  for(int i = 0; i < size; i++){
+    //fullVector<double> uv = jac->invMap(x, y);
+
+    //res += (*basis)[i].at(uv(0), uv(1), 0.0);
+  }
+
+  //return res;
+
 }

FunctionSpace/LocalFunctionSpace1Form.h

@@ -12,11 +12,14 @@
 #include "Polynomial.h"
 #include "Basis.h"
 #include "Element.h"
+#include "Jacobian.h"
 #include "LocalFunctionSpaceVector.h"
 
 class LocalFunctionSpace1Form: public LocalFunctionSpaceVector{
  private:
   const std::vector<std::vector<Polynomial> >* basis;
+  Jacobian* jac;
+  const std::vector<int>* orient;
 
  public:
   //! Instantiate a new LocalFunctionSpace1Form

FunctionSpace/LocalFunctionSpaceScalar.h

 #ifndef _LOCALFUNCTIONSPACESCALAR_H_
 #define _LOCALFUNCTIONSPACESCALAR_H_
 
+#include <vector>
+#include "Polynomial.h"
 #include "LocalFunctionSpace.h"
 
 /**