compiling version

[[Imported from SVN: r2720]]

fem/discretefunction/adaptivefunction.cc

@@ -6,8 +6,37 @@ namespace Dune {
   //- AdaptiveDiscreteFunction
   // nothing here, everything in adaptivefunction.hh
 
-  //- AdaptiveDiscreteFunction
-  // comes later
+  //- AdaptiveDiscreteFunction (specialisation)
+  /*
+     template <class ContainedFunctionSpaceImp, int N,
+            DofStoragePolicy p, class DofManagerImp>
+     AdaptiveDiscreteFunction<
+     CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+     ~AdaptiveDiscreteFunction()
+     {
+     for (int i = 0; i < subSpaces_.size(); ++i) {
+      delete subSpaces_[i];
+      subSpaces_[i] = 0;
+     }
+     }
+
+     template <class ContainedFunctionSpaceImp, int N,
+            DofStoragePolicy p, class DofManagerImp>
+     AdaptiveDiscreteFunction<
+     CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+     SubDiscreteFunctionType
+     AdaptiveDiscreteFunction<
+     CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+     subFunction(int component)
+     {
+     SubSpaceType* subSpace = new SubSpaceType(this->space(), component);
+     subSpaces_.push_back(subSpace);
+
+     return SubDiscreteFunctionType(std::string("Subfunction of ") + name(),
+     *subSpace,
+                                   this->memObject());
+     }
+   */
 
   //- AdaptiveLocalFunction
   template <class DiscreteFunctionSpaceImp, class DofManagerImp>

fem/discretefunction/adaptivefunction.hh

@@ -55,6 +55,9 @@ namespace Dune {
     private AdaptiveFunctionImplementation<
         DiscreteFunctionSpaceImp, DofManagerImp>
   {
+  public:
+    //- friends
+
   private:
     typedef AdaptiveDiscreteFunction<
         DiscreteFunctionSpaceImp, DofManagerImp> MyType;
@@ -70,7 +73,6 @@ namespace Dune {
     typedef Imp ImplementationType;
     typedef DiscreteFunctionSpaceImp DiscreteFunctionSpaceType;
 
-
     typedef typename Traits::LocalFunctionType LocalFunctionType;
     typedef typename Traits::DiscreteFunctionType DiscreteFunctionType;
 
@@ -94,6 +96,14 @@ namespace Dune {
       Imp(name, spc)
     {}
 
+    //! Constructor for SubDiscreteFunctions
+    AdaptiveDiscreteFunction(std::string name,
+                             const DiscreteFunctionSpaceType& spc,
+                             MemObjectType& memObject) :
+      BaseType(spc),
+      Imp(name, spc, memObject)
+    {}
+
     //! Copy constructor
     //! The copy constructor copies the dofs
     AdaptiveDiscreteFunction(const MyType& other) :
@@ -216,38 +226,67 @@ namespace Dune {
   }; // end class AdaptiveLocalFunction
 
   //- Specialisations
-  /* Do that later
-
-     template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
-     class AdaptiveDiscreteFunction<CombinedSpace<ContainedFunctionSpaceImp, N, p> > :
-     public DiscreteFunctionDefault<
-     AdaptiveDiscreteFunctionTraits<CombinedSpace<ContainedFunctionSpaceImp, N, p> >
-     >,
-     private AdaptiveFunctionImplementation<CombinedSpace<ContainedFunctionSpaceImp, N, p> >
+  /*
+     template <class ContainedFunctionSpaceImp, int N,
+            DofStoragePolicy p, class DofManagerImp>
+     class AdaptiveDiscreteFunction<
+     CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp> :
+     public DiscreteFunctionDefault<AdaptiveDiscreteFunctionTraits<CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp > >,
+     private AdaptiveFunctionImplementation<CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>
      {
      private:
-     typedef CombinedSpace<ContainedFunctionSpaceImp, N, p> DiscreteFunctionSpaceImp;
-     typedef AdaptiveDiscretFunction<DiscreteFunctionSpaceImp> MyType;
-     typedef AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp> Imp;
-     typedef AdaptiveDiscreteFunctionTraits<DiscreteFunctionSpaceImp> MyTraits;
+     typedef CombinedSpace<
+      ContainedFunctionSpaceImp, N, p> DiscreteFunctionSpaceImp;
+     typedef AdaptiveDiscreteFunction<
+      DiscreteFunctionSpaceImp, DofManagerImp> MyType;
+     typedef AdaptiveFunctionImplementation<
+      DiscreteFunctionSpaceImp, DofManagerImp> Imp;
+     typedef AdaptiveDiscreteFunctionTraits<
+      DiscreteFunctionSpaceImp, DofManagerImp> MyTraits;
      typedef DiscreteFunctionDefault<MyTraits> BaseType;
 
      public:
      //- Typedefs and enums
      typedef MyTraits Traits;
+     typedef Imp ImplementationType;
      typedef DiscreteFunctionSpaceImp DiscreteFunctionSpaceType;
 
      typedef typename Traits::LocalFunctionType LocalFunctionType;
      typedef typename Traits::DiscreteFunctionType DiscreteFunctionType;
 
+     typedef typename Traits::DofType DofType;
+     typedef typename Traits::RangeFieldType RangeFieldType;
+     typedef typename Traits::RangeType RangeType;
+     typedef typename Traits::DomainType DomainType;
+     typedef typename Traits::MapperType MapperType;
+
+     typedef typename Traits::DofStorageType DofStorageType;
+     typedef typename Traits::MemObjectType MemObjectType;
+
+     //- Additional typedefs
+     typedef SubSpace<> SubSpaceType;
+     typedef AdaptiveDiscreteFunction<
+      SubSpaceType, DofManagerImp> SubDiscreteFunctionType;
+
      public:
      //- Public methods
-     AdaptiveDiscreteFunction(const DiscreteFunctionSpaceType& spc,
-                             std::string name = "no name") :
+     //! Constructor
+     AdaptiveDiscreteFunction(std::string name,
+                             const DiscreteFunctionSpaceType& spc) :
       BaseType(spc),
-      Imp(name)
+      Imp(name, spc),
+      subSpaces_(0)
+     {}
+
+     //! Copy constructor
+     AdaptiveDiscreteFunction(const MyType& other) :
+      BaseType(other.space()),
+      Imp(other),
+      subSpaces(0) // Don't copy them
      {}
 
+     ~AdaptiveDiscreteFunction();
+
      using Imp::name;
      using Imp::dbegin;
      using Imp::dend;
@@ -259,11 +298,18 @@ namespace Dune {
      using Imp::read_ascii;
      using Imp::write_pgm;
      using Imp::read_pgm;
+
      //- Additional methods
+     SubDiscreteFunctionType subFunction(int component);
+
+     int numComponents() const { return N; }
 
      private:
+     std::vector<SubSpaceType*> subSpaces_;
      }; // end class AdaptiveDiscreteFunction (specialised for CombinedSpace)
    */
+
+  //- class AdaptiveLocalFunction (specialised)
   template <
       class ContainedFunctionSpaceImp, int N,
       DofStoragePolicy p, class DofManagerImp

fem/discretefunction/adaptiveimp.cc

@@ -14,6 +14,19 @@ namespace Dune {
     dofVec_(memObj_.getArray())
   {}
 
+  /*
+     template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+     AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+     AdaptiveFunctionImplementation(std::string name,
+                                 const DiscreteFunctionSpaceType& spc,
+                                 MemObjectType& memObject) :
+     spc_(spc),
+     name_(name),
+     dm_(DofManagerFactory<DofManagerType>::getDofManager(spc.grid())),
+     memObj_(memObject),
+     dofVec_(memObject.getArray())
+     {}
+   */
   template <class DiscreteFunctionSpaceImp, class DofManagerImp>
   AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
   AdaptiveFunctionImplementation(const ThisType& other) :
@@ -32,7 +45,6 @@ namespace Dune {
   ~AdaptiveFunctionImplementation()
   {
     bool removed = dm_.removeDofSet(memObj_);
-
     assert(removed);
   }
 
@@ -81,7 +93,8 @@ namespace Dune {
   }
 
   template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::LocalFunctionType
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  LocalFunctionType
   AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
   newLocalFunction()
   {

fem/discretefunction/adaptiveimp.hh

@@ -31,16 +31,15 @@ namespace Dune {
         DiscreteFunctionSpaceImp, DofManagerImp> ThisType;
     typedef AdaptiveDiscreteFunctionTraits<
         DiscreteFunctionSpaceImp, DofManagerImp> Traits;
+
     typedef typename Traits::DofIteratorType DofIteratorType;
     typedef typename Traits::ConstDofIteratorType ConstDofIteratorType;
     typedef typename Traits::LocalFunctionType LocalFunctionType;
+    typedef typename Traits::MapperType MapperType;
 
     typedef typename DiscreteFunctionSpaceImp::Traits SpaceTraits;
     typedef typename SpaceTraits::RangeFieldType RangeFieldType;
 
-    typedef typename Traits::DofIteratorType DofIteratorType;
-    typedef typename Traits::ConstDofIteratorType ConstDofIteratorType;
-    typedef typename Traits::MapperType MapperType;
 
     typedef typename Traits::DofStorageType DofStorageType;
     typedef typename Traits::MemObjectType MemObjectType;
@@ -78,9 +77,13 @@ namespace Dune {
 
   protected:
     const DiscreteFunctionSpaceType& space() const { return spc_; }
+    MemObjectType& memObject() { return memObj_; }
 
     AdaptiveFunctionImplementation(std::string name,
                                    const DiscreteFunctionSpaceType& spc);
+    AdaptiveFunctionImplementation(std::string name,
+                                   const DiscreteFunctionSpaceType& spc,
+                                   MemObjectType& memObject);
     AdaptiveFunctionImplementation(const ThisType& other);
     ~AdaptiveFunctionImplementation();
 
@@ -90,7 +93,7 @@ namespace Dune {
     DofManagerType& dm_;
     MemObjectType& memObj_;
     DofStorageType& dofVec_;
-  };  // end class AdaptiveFunctionImplementation
+  }; // end class AdaptiveFunctionImplementation
 
 } // end namespace Dune