estimator.hh

Go to the documentation of this file.

 
#ifndef estimator_hh
#define estimator_hh
 
 
#include "formula/piecewiseFormula.hh"
#include "space/space.hh"
#include "toolbox/hashMap.hh"
#include "function/vector.hh"
 
namespace concepts{
 
template<typename F>
class Estimator: public OutputOperator {
 
public:
  const Real getGlobal() const {
    return globError_;
  }
 
protected:
 
  Estimator(const concepts::SpaceOnCells<F>& spc, const concepts::Vector<F>& sol) :
      spc_(spc), sol_(sol) {};
 
  virtual std::ostream& info(std::ostream& os) const=0;
  //local reference to the Space
  const concepts::SpaceOnCells<F>& spc_;
  //local reference to the solution
  const concepts::Vector<F>& sol_;
  //the global error
  Real globError_;
};
 
// * Abstract class representing error estimators in one dimension.
// */
//template<typename F>
//class Estimator1D : public concepts::Estimator<F>{
//
//  public:
//    Estimator1D(const concepts::SpaceOnCells<F>& spc,const concepts::Vector<F>& sol):Estimator<F>(spc,sol){};
//
//    protected:
//      virtual std::ostream& info(std::ostream& os) const;
//
//
//};
//
//
// * Abstract class representing error estimators in two dimensions.
// */
//template<typename F>
//class Estimator2D : public concepts::Estimator<F>{
//
//  public:
//    Estimator2D(const concepts::SpaceOnCells<F>& spc,const concepts::Vector<F>& sol):Estimator<F>(spc,sol){};
//
//    protected:
//      virtual std::ostream& info(std::ostream& os) const;
//
//
//};
//
// * Abstract class representing error estimators in three dimensions.
// */
//template<typename F>
//class Estimator3D : public concepts::Estimator<F>{
//
//  public:
//    Estimator3D(const concepts::SpaceOnCells<F>& spc,const concepts::Vector<F>& sol):Estimator<F>(spc,sol){};
//
//    protected:
//      virtual std::ostream& info(std::ostream& os) const;
//};
 
 
template<class F>
class LocalEstimator : public concepts::Estimator<F>,  public concepts::PiecewiseFormulaBase<F>{
 
public:
 
  typedef HashMap<Real>::iterator iterator;
  typedef HashMap<Real>::const_iterator const_iterator;
 
 
  //#################         Iterator section
  inline iterator begin() {
    return iterator(locError_.begin());
  }
 
  inline const_iterator begin() const {
    return const_iterator(locError_.begin());
  }
 
  inline iterator end() {
    return iterator(locError_.end());
  }
 
  inline const_iterator end() const {
    return const_iterator(locError_.end());
  }
 
  inline uint nelm() const{
    return locError_.size();
  }
 
  const Real operator()(uint key)const{
    concepts::HashMap<Real>::const_iterator iter = locError_.find(key);
    conceptsAssert(iter!=locError_.end(), concepts::Assertion());
    return iter->second;
  }
 
  virtual LocalEstimator<F>* clone() const = 0;
 
 
  virtual F operator()(const Connector& cntr, const Real p,const Real t = 0.0) const{
    return this->operator()(cntr.key());
  }
  virtual F operator()(const Connector& cntr, const Real2d& p, const Real t = 0.0) const{
    return this->operator()(cntr.key());
  }
  virtual F operator()(const Connector& cntr, const Real3d& p, const Real t = 0.0) const{
    return this->operator()(cntr.key());
  }
 
protected:
 
  //private constructor on may not create instance of this abstract class
  LocalEstimator(const concepts::SpaceOnCells<F>& spc, const concepts::Vector<F>& sol):Estimator<F>(spc,sol){};
 
 
  virtual std::ostream& info(std::ostream& os) const=0;
 
    //mapping of elements keys to local errors
    concepts::HashMap<Real> locError_;
 
};
 
//further possible abstract classes :
 
//class SubdomainEstimator
//class GoalOrientedEstimator
 
 
}
 
#endif // estimator_hh