diff --git a/FunctionSpace/FunctionSpace.cpp b/FunctionSpace/FunctionSpace.cpp
index 6b2550f5c513e335742985bc5f140e66ab82d6ef..eea1a54c033021444935bb609c38adeb25ed980b 100644
--- a/FunctionSpace/FunctionSpace.cpp
+++ b/FunctionSpace/FunctionSpace.cpp
@@ -10,10 +10,6 @@
 using namespace std;
 
 FunctionSpace::FunctionSpace(void){
-  // No Dof //
-  dof    = NULL;
-  group  = NULL;
-  eToGod = NULL;
 }
 
 FunctionSpace::~FunctionSpace(void){
@@ -21,23 +17,6 @@ FunctionSpace::~FunctionSpace(void){
   //   (FunctionSpace is not responsible for
   //    'true' Basis Deletion)
   delete basis;
-
-  // Dof //
-  if(dof)
-    delete dof;
-
-  // Group //
-  if(group){
-    size_t nElement = group->size();
-
-    for(size_t i = 0; i < nElement; i++)
-      delete (*group)[i];
-    delete group;
-  }
-
-  // Element To GoD //
-  if(eToGod)
-    delete eToGod;
 }
 
 void FunctionSpace::build(GroupOfElement& goe,
@@ -88,11 +67,7 @@ void FunctionSpace::buildDof(void){
   const vector<const MElement*>& element = goe->getAll();
 
   // Init Struct //
-  dof      = new set<Dof>;
-  group    = new vector<GroupOfDof*>(nElement);
-  eToGod   = new map<const MElement*,
-                     const GroupOfDof*,
-                     ElementComparator>;
+  group.resize(nElement);
 
   // Create Dofs //
   for(size_t i = 0; i < nElement; i++){
@@ -100,47 +75,18 @@ void FunctionSpace::buildDof(void){
     vector<Dof> myDof = getKeys(*(element[i]));
     size_t nDof       = myDof.size();
 
-    // Add Dof
+    // Add Dofs
     for(size_t j = 0; j < nDof; j++)
-      dof->insert(myDof[j]);
-    //vector<Dof> trueDof(nDof);
+      dof.insert(myDof[j]);
 
-    //for(size_t j = 0; j < nDof; j++)
-    //insertDof(myDof[j], trueDof, j);
-
-    // Create new GroupOfDof
-    GroupOfDof* god = new GroupOfDof(*(element[i]), myDof);
-    (*group)[i]     = god;
+    // Save vectorCreate new GroupOfDof
+    group[i] = myDof;
 
     // Map GOD
-    eToGod->insert(pair<const MElement*, const GroupOfDof*>
-                   (element[i], god));
-  }
-}
-/*
-void FunctionSpace::insertDof(Dof& d,
-                              vector<const Dof*>& trueDof,
-                              size_t index){
-  // Copy 'd'
-  const Dof* tmp = new Dof(d);
-
-  // Try to insert Dof //
-  pair<set<const Dof*, DofComparator>::iterator, bool> p
-    = dof->insert(tmp);
-
-  // If insertion is OK (Dof 'd' didn't exist) //
-  //   --> Add new Dof in GoD
-  if(p.second)
-    trueDof[index] = tmp;
-
-  // If insertion failed (Dof 'd' already exists) //
-  //   --> delete 'tmp' and add existing Dof in GoD
-  else{
-    delete tmp;
-    trueDof[index] = *(p.first);
+    eToGod.insert
+      (pair<const MElement*, const vector<Dof>*>(element[i], &group[i]));
   }
 }
-*/
 
 vector<Dof> FunctionSpace::getUnorderedKeys(const MElement& elem) const{
   // Const_Cast //
@@ -266,14 +212,14 @@ void FunctionSpace::getKeys(const GroupOfElement& goe,
   }
 }
 
-
-const GroupOfDof& FunctionSpace::
+const std::vector<Dof>& FunctionSpace::
 getGoDFromElement(const MElement& element) const{
 
-  const map<const MElement*, const GroupOfDof*, ElementComparator>::iterator
-    it = eToGod->find(&element);
+  const map<const MElement*,
+            const std::vector<Dof>*,
+            ElementComparator>::const_iterator it = eToGod.find(&element);
 
-  if(it == eToGod->end())
+  if(it == eToGod.end())
     throw
       Exception("Their is no GroupOfDof associated with the given MElement: %d",
                 element.getNum());
diff --git a/FunctionSpace/FunctionSpace.h b/FunctionSpace/FunctionSpace.h
index ee555ba427d54020d7c4e46b8bb29386f260c913..5bf23dbc81b8cd0c9e5d2ba9c1999d61dc09db33 100644
--- a/FunctionSpace/FunctionSpace.h
+++ b/FunctionSpace/FunctionSpace.h
@@ -8,7 +8,6 @@
 
 #include "Comparators.h"
 #include "Dof.h"
-#include "GroupOfDof.h"
 
 #include "Mesh.h"
 #include "GroupOfElement.h"
@@ -58,11 +57,11 @@ class FunctionSpace{
   bool scalar;
 
   // Dofs //
-  std::set<Dof>*            dof;
-  std::vector<GroupOfDof*>* group;
+  std::set<Dof>                  dof;
+  std::vector<std::vector<Dof> > group;
   std::map<
     const MElement*,
-    const GroupOfDof*, ElementComparator>* eToGod;
+    const std::vector<Dof>*, ElementComparator> eToGod;
 
  public:
   virtual ~FunctionSpace(void);
@@ -82,26 +81,16 @@ class FunctionSpace{
 
   void getKeys(const GroupOfElement& goe, std::set<Dof>& dof) const;
 
-  const std::set<Dof>&            getAllDofs(void) const;
-  const std::vector<GroupOfDof*>& getAllGroups(void) const;
+  const std::set<Dof>&                  getAllDofs(void)   const;
+  const std::vector<std::vector<Dof> >& getAllGroups(void) const;
 
-  const GroupOfDof& getGoDFromElement(const MElement& element) const;
-
-  size_t dofNumber(void) const;
-  size_t groupNumber(void) const;
+  const std::vector<Dof>& getGoDFromElement(const MElement& element) const;
 
  protected:
-  // Init
   FunctionSpace(void);
 
-  void build(GroupOfElement& goe,
-             const Basis& basis);
-
-  // Dof
+  void build(GroupOfElement& goe, const Basis& basis);
   void buildDof(void);
-  void insertDof(Dof& d,
-                 std::vector<const Dof*>& trueDof,
-                 size_t index);
 };
 
 
@@ -203,20 +192,13 @@ inline bool FunctionSpace::isScalar(void) const{
   return scalar;
 }
 
-inline size_t FunctionSpace::dofNumber(void) const{
-  return dof->size();
-}
-
-inline size_t FunctionSpace::groupNumber(void) const{
-  return group->size();
-}
-
 inline const std::set<Dof>& FunctionSpace::getAllDofs(void) const{
-  return *dof;
+  return dof;
 }
 
-inline const std::vector<GroupOfDof*>& FunctionSpace::getAllGroups(void) const{
-  return *group;
+inline const std::vector<std::vector<Dof> >&
+FunctionSpace::getAllGroups(void) const{
+  return group;
 }
 
 #endif