exactEstimator.hh

#ifndef exactEstimator_hh
#define exactEstimator_hh
 
#include "estimator.hh"
 
//TODO: Precise the includes
#include "hp2D.hh"
#include "formula.hh"
#include "basics/exceptions.hh"
 
using concepts::Real;
 
namespace estimator{
 
 
 
template<class F = Real>
class ExactEstimator: public LocalEstimator<F>{
 
public:
 
  ExactEstimator(const concepts::SpaceOnCells<F>& spc,
           const concepts::Vector<F>& sol):
       LocalEstimator<F>(spc, sol){};
 
 
 
  template<class G, class H>
  void addErrorContr(const concepts::ElementFormula<G>* efrm,
            const concepts::ElementFormula<H>* afrm,
            Real s = 1.0,
            const concepts::ElementFormula<F>* w = 0)
  {
    //frm must exist, i.e. avoid clone
    conceptsAssert(efrm && afrm, concepts::Assertion());
    std::auto_ptr<typename concepts::SpaceOnCells<F>::Scanner > sc(this->spc_.scan());
      while (!sc->eos()) {
        concepts::ElementWithCell<F>& elm = (*sc)++;
        //current key of element
        uint K = elm.cell().connector().key();
        //set the error of the solution in the requested norm
        Real error_K = 0;
        if (w)
          error_K += s * concepts::L2product(elm,
              *w * (*efrm - * afrm) );
        else
          error_K += s * concepts::L2product(elm, *efrm - * afrm);
        //add current error squared
        this->globError_ += error_K;
        //here the global error must be increased and later square rooted
        LocalEstimator<F>::locError_[K] += error_K;
      }//loop over space elements
  }
 
 
  //completes error computation
  void compute(){
 
    //take squareroot of local final contribution
    typename LocalEstimator<F>::iterator err_K = this->begin();
    for( ; err_K != this->end(); err_K ++)
      err_K->second = std::sqrt(err_K->second);
 
 
    this->globError_ = std::sqrt(this->globError_);
    //compute element residuals and errors with jumpresiduals
    // computeError_();
  }
 
  virtual ExactEstimator<F>* clone() const{return new ExactEstimator<F>(*this);}
 
protected:
 
  virtual std::ostream& info(std::ostream& os) const{
    return os << "Exact local error Estimator()";
  }
 
 
private:
 
 
  //  //norm construction stuff
  concepts::Sequence<const concepts::ElementFormula<F>* > norm_exact_fs_;
  concepts::Sequence<const concepts::ElementFormula<F>* > norm_apprx_fs_;
  concepts::Sequence<const concepts::ElementFormula<F>* > norm_ws_;
  concepts::Sequence<Real> norm_s_;
 
//  virtual void computeError_(){
//
//    std::auto_ptr<typename concepts::SpaceOnCells<F>::Scanner > sc(this->spc_.scan());
//    while (!sc->eos()) {
//      concepts::ElementWithCell<F>& elm = (*sc)++;
//      //current key of element
//      uint K = elm.cell().connector().key();
//
//      //set the error of the solution in the requested norm
//      Real error_K = 0;
//      for(uint n = 0; n < norm_exact_fs_.size(); ++n){
//        if (norm_ws_[n])
//          error_K += norm_s_[n] * concepts::L2product(elm,
//              *(norm_ws_[n]) * (*(norm_exact_fs_[n])
//                      - *(norm_apprx_fs_[n])));
//        else
//          error_K += norm_s_[n] * concepts::L2product(elm,
//              *(norm_exact_fs_[n]) - *(norm_apprx_fs_[n]));
//      }//for n-th contribution
//
//      //add current error squared
//      this->globError_ += error_K;
//      //here the global error must be increased and later square rooted
//      LocalEstimator<F>::locError_[K] = std::sqrt(error_K);
//      DEBUGL(COMPUTE_D, "estimated error on K = " << K << "  : " << LocalEstimator<F>::locError_[K])
//    }//loop over space elements
//    //take square root to obtain global error
//    this->globError_ = std::sqrt(this->globError_);
//  }//compute Error
 
 
};//class exact Error
 
 
 
 
} // namespace estimator
 
#endif // exactEstimator_hh