estimatorinterface.hh

#ifndef __ESTIMATOR_INTERFACE_HH__
#define __ESTIMATOR_INTERFACE_HH__
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
namespace Dune {
 
  namespace ACFem {
 
    enum FunctionSpaceNorm
    {
      L2Norm,
      H1Norm
    };
 
    template<class Estimator>
    struct EstimatorTraits
    {
      typedef void DiscreteFunctionSpaceType;
      typedef void IteratorType;
    };
 
    template<class Estimator>
    class EstimatorInterface
      : public Dune::Fem::BartonNackmanInterface<EstimatorInterface<Estimator>,
                                                 Estimator>
    {
      typedef EstimatorInterface ThisType;
      typedef Estimator ImplementationType;
      typedef EstimatorTraits<ImplementationType> TraitsType;
      typedef Dune::Fem::BartonNackmanInterface<ThisType, ImplementationType> BaseType;
      using BaseType::asImp;
     protected:
      EstimatorInterface() {}
      EstimatorInterface(const EstimatorInterface& other) {}
      EstimatorInterface& operator=(const EstimatorInterface& other) {}
     public:
      typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
      typedef typename DiscreteFunctionSpaceType::GridPartType::GridType GridType;
      typedef typename GridType::template Codim<0>::Entity ElementType;
      typedef typename TraitsType::IteratorType IteratorType;
 
      template<class DiscreteFunctionType>
      RangeFieldType estimate(const DiscreteFunctionType& uh)
      {
        return asImp().estimate(uh);
      }
 
      size_t size() const {
        return asImp().size();
      }
 
      IteratorType begin() const {
        return asImp().begin();
      }
 
      IteratorType end() const {
        return asImp().end();
      }
 
      const RangeFieldType& operator[](const size_t& idx) const
      {
        return asImp()[idx];
      }
 
      const RangeFieldType& operator[](const ElementType& entity) const
      {
        return asImp()[entity];
      }
 
      GridType& grid() const {
        return asImp().grid();
      }
 
      const DiscreteFunctionSpaceType& space() const
      {
        return asImp().space();
      }
    };
 
// No real default, just for completeness.
    template<class Estimator>
    class DefaultEstimator
      : public EstimatorInterface<Estimator>
    {
      typedef Estimator ImplementationType;
      typedef EstimatorInterface<ImplementationType> BaseType;
      typedef DefaultEstimator<ImplementationType> ThisType;
      typedef EstimatorTraits<ImplementationType> TraitsType;
     protected:
      DefaultEstimator() {}
      DefaultEstimator(const DefaultEstimator& other) {}
      DefaultEstimator& operator=(const DefaultEstimator& other) {}
     public:
      typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
      typedef typename FunctionSpaceType::RangeFieldType RangeFieldType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename GridPartType::GridType GridType;
      typedef typename GridType::template Codim<0>::Entity ElementType;
 
      template<class DiscreteFunctionType>
      RangeFieldType estimate(const DiscreteFunctionType& uh)
      {
        return -1.0;
      }
 
      size_t size() const {
        return 0;
      }
 
      const RangeFieldType& operator[](const size_t& idx) const
      {
        return -1.0;
      }
 
      const RangeFieldType& operator[](const ElementType& entity) const
      {
        return -1.0;
      }
 
 
 
    };
 
  } // ACFem
} // Dune
 
#endif //  __ESTIMATOR_INTERFACE_HH__