marking.hh

#ifndef marking_hh
#define marking_hh
 
#include "estimator/estimator.hh"
//#include "meshGraph.hh"
 
namespace estimator{
 
// marking refinementstrategies like dörfler are not in that design atm
 
class Marking : public concepts::OutputOperator{
public:
  inline const concepts::Set<uint>& marks() const{return mark_;}
protected:
  concepts::Set<uint> mark_;
};
 
 
struct error_index: public concepts::OutputOperator{
  error_index(uint elmkey, concepts::Real error):err(error),key(elmkey){};
 
  bool operator<(error_index const& right) const {
    if(this->err ==  right.err)
      return this->key < right.key;
      return this->err < right.err;
   }
 
  bool operator!=(error_index const& right){
    return (this->err != right.err) || (this->key != right.key);
  }
 
  concepts::Real err;
  uint key;
 
protected:
  virtual std::ostream& info(std::ostream& os) const {
    return os << "error_index("<<err<<","<<key<<")";
  }
};
 
 
//Absolute marking, choosing absolute number of cells
class AMarking : public Marking{
 
public:
  template<class F= concepts::Real>
  AMarking(const concepts::Estimator<F>& estimator, uint no){
 
    const concepts::LocalEstimator<F>* locEstimator = dynamic_cast<const concepts::LocalEstimator<F>*>(&estimator);
    if(locEstimator){
 
      concepts::Set<error_index> locErrors;
      typename concepts::LocalEstimator<F>::const_iterator iter;
      //sort all errors
      for( iter= locEstimator->begin(); iter != locEstimator->end(); ++iter)
        locErrors.insert(error_index(iter->first, iter->second));
 
      //get the maximal local error = last element in Set
      //Real maxErr = locErrors.rbegin()->err;
      concepts::Set<error_index>::const_reverse_iterator iterSet = locErrors.rbegin();
 
 
      for( uint i = 0; (iterSet != locErrors.rend()) && i < no; ++i)
          this->mark_.insert((iterSet++)->key);
    }else //just localEstimators are implemented right now
       throw conceptsException(concepts::MissingFeature("not implemented"));
 
 
  }
 
 
 
 
protected:
  virtual std::ostream& info(std::ostream& os) const {
    return os << "Absolute Marking( "<< this->mark_<<")";
  }
};
 
 
 
 
 
 
 
 
//bulk marking
class BMarking : public Marking{
 
public:
  template<class F= concepts::Real>
  BMarking(const concepts::Estimator<F>& estimator, concepts::Real theta = 0.7){
 
    const concepts::LocalEstimator<F>* locEstimator = dynamic_cast<const concepts::LocalEstimator<F>*>(&estimator);
    if(locEstimator){
 
      concepts::Set<error_index> locErrors;
      typename concepts::LocalEstimator<F>::const_iterator iter;
      //sort all errors
      for( iter= locEstimator->begin(); iter != locEstimator->end(); ++iter)
        locErrors.insert(error_index(iter->first, iter->second));
 
      //get the maximal local error = last element in Set
      concepts::Real maxErr = locErrors.rbegin()->err;
 
      //DEBUGL(1, locErrors);
 
      for( iter= locEstimator->begin(); iter != locEstimator->end(); ++iter){
        if(iter->second > theta * maxErr )
          this->mark_.insert(iter->first);
      }
    }else //just localEstimators are implemented right now
       throw conceptsException(concepts::MissingFeature("not implemented"));
 
 
  }
 
 
 
 
protected:
  virtual std::ostream& info(std::ostream& os) const {
    return os << "Marking( "<< this->mark_<<")";
  }
 
 
 
};
 
class MVMarking : public Marking{
public:
  template<class F= concepts::Real>
  MVMarking(const concepts::LocalEstimator<F>& estimator, concepts::Real sigma = 0.75): sigma_(sigma){
    //sum all local errors squared
    concepts::Real sum = 0.0;
 
    typename concepts::LocalEstimator<F>::const_iterator iter;
    for( iter = estimator.begin(); iter != estimator.end(); ++iter)
      sum += iter->second * iter->second;
    //compute the mean value
    oEta_2_ = sum / estimator.nelm();
 
    for( iter = estimator.begin(); iter != estimator.end(); ++iter){
      if (sigma * oEta_2_ <  iter->second * iter->second)
        this->mark_.insert(iter->first);
    }
  }
 
  //inline const Set<uint>& marks() const{  return mark_;}
 
protected:
  virtual std::ostream& info(std::ostream& os) const {
    os << "MVMarking[ mean error = " << oEta_2_ << " << sigma_ = "<< sigma_ << " #marked Elements = "<<this->mark_.size() <<"]";
    return os << " marked elements : "<< this->mark_ << std::endl;
  }
 
private:
  //mean value of error squared : \overline\eta^2
  concepts::Real oEta_2_;
  //choose value
  concepts::Real sigma_;
//  //set of key of tagged elements
//  concepts::Set<uint> mark_;
 
};
 
 
 
 
 
 
 
 
 
 
}
 
 
 
 
 
 
 
 
 
 
#endif // marking_hh