refinementGraphics.hh

Go to the documentation of this file.

 
#ifndef refinementGraphics_hh
#define refinementGraphics_hh
 
#include "formula/piecewiseFormula.hh"
using concepts::Real;
 
namespace estimator{
 
template<ushort dim = 2>
class PolynomialDegrees : public concepts::PiecewiseFormulaBase<Real>{
public:
 
  template<class F=Real>
  PolynomialDegrees(const concepts::SpaceOnCells<F>& space){
 
    const hp2D::hpAdaptiveSpace<F>* spc = dynamic_cast<const hp2D::hpAdaptiveSpace<F>* >(&space);
      if(spc){
        //information about the polynomial degree
        hp2D::hpFull& hpfull = spc->prebuild();
        std::unique_ptr<hp2D::hpAdaptiveSpaceH1::Scanner> sc(spc->scan());
          while (*sc) {
            concepts::ElementWithCell<Real>& elm = (*sc)++;
            //key of current element
            uint K = elm.cell().connector().key().key();
            const concepts::Connector2* cntr =
                dynamic_cast<const concepts::Connector2*>(&elm.cell().connector());
            //the cntr must be 2d since it is out of hpAdaptiveSpace
            conceptsAssert(cntr, concepts::Assertion());
 
            cntr_[K] = cntr;
            //set maximal polynomial degree (i.e inner), if no inner exists
            // default is 1 if there is a vertex dof on this cell
            const ushort* pMax = hpfull.innerDof(*cntr);
 
            //no inner dof
            if(pMax == 0){
              //check if there is at least one dof, i.e a vertex dof
              //this has 4 vertexList searches (costs?)
              bool hasVDof = (hpfull.vtxDof(*cntr, 0) || hpfull.vtxDof(*cntr, 1) ||
                    hpfull.vtxDof(*cntr, 2) || hpfull.vtxDof(*cntr, 3));
              if(hasVDof){
                //set default to one
                p_[K] = concepts::Array<ushort>(dim);
                for(ushort i = 0 ; i < dim; ++i)
                  p_[K][i] = 1;
              }else{
                //no dofs on vertices, e.g. :
                //
                // Cell x for h=1 only has hanging nodes as vertices and is therefore not supported
                //  __________
                // |__________|
                // |   |x|    |
                // |   |_|
                // |___|_|____|
                throw conceptsException(concepts::MissingFeature("Cell has no vertex dofs, cannot be handled atm"));
              }
            }else{
              //has inner Dof and therefore a polynomial degree >= 2
              p_[K] = concepts::Array<ushort>(dim);
              for(ushort i = 0 ; i < dim; ++i)
                 p_[K][i] = std::max(pMax[i], hpfull.edgeDof(*cntr, i));
            }
          }
    }else//no hp2D space
       throw conceptsException(concepts::MissingFeature("Currently just hpAdaptiveSpace supported"));
  }//constructor
 
 virtual Real operator()(const concepts::Connector& cntr, const Real p, const Real t = 0.0) const{
   //key of current Element
   uint K = cntr.key();
   //check if same connector
   //const concepts::Connector* cntr2 = cntr_.find(K)->second;
   if( (&cntr) == cntr_.find(K)->second){
     concepts::HashMap<concepts::Array<ushort> >::const_iterator iter = p_.find(K);
     if(iter != p_.end()){
       conceptsAssert(iter->second[0] == iter->second[1] && dim == 2, concepts::Assertion());
       return iter->second[0];
     }
   }
   return 0;
 }
 
 virtual Real operator()(const concepts::Connector& cntr, const concepts::Real2d& p, const Real t = 0.0) const{
   //key of current Element
   uint K = cntr.key();
   //check if same connector
   //const concepts::Connector* cntr2 = cntr_.find(K)->second;
   if( (&cntr) == cntr_.find(K)->second){
     concepts::HashMap<concepts::Array<ushort> >::const_iterator iter = p_.find(K);
     if(iter != p_.end()){
       conceptsAssert(iter->second[0] == iter->second[1] && dim == 2, concepts::Assertion());
       return iter->second[0];
     }
   }
   return 0;
 }
 
 virtual Real operator()(const  concepts::Connector& cntr, const concepts::Real3d& p, const Real t = 0.0) const{
   //key of current Element
   uint K = cntr.key();
   //check if same connector
   //const concepts::Connector* cntr2 = cntr_.find(K)->second;
   if( (&cntr) == cntr_.find(K)->second){
     concepts::HashMap<concepts::Array<ushort> >::const_iterator iter = p_.find(K);
     if(iter != p_.end()){
       conceptsAssert(iter->second[0] == iter->second[1] && dim == 2, concepts::Assertion());
       return iter->second[0];
     }
   }
   return 0;
 }
 
virtual PolynomialDegrees<dim>* clone() const{return new PolynomialDegrees<dim>(*this);}
 
protected:
 virtual std::ostream& info(std::ostream& os) const{
   return os << concepts::typeOf(*this) << " : " << p_ << "]";
 }
 
private:
 concepts::HashMap<concepts::Array<ushort> > p_;
 
 //map from key to connector to check later
 concepts::HashMap<const concepts::Connector*> cntr_;
 
}; //class
 
 
 
 
 
 
template<class F = Real>
class KeysInfo : public concepts::PiecewiseFormulaBase<Real>{
public:
  KeysInfo(){}
 
 virtual F operator()(const concepts::Connector& cntr, const Real p, const Real t = 0.0) const{
   //key of current Element
   uint K = cntr.key();
   return K;
 }
 
 virtual F operator()(const concepts::Connector& cntr, const concepts::Real2d& p, const Real t = 0.0) const{
   //key of current Element
     uint K = cntr.key();
     return K;
 }
 
 virtual F operator()(const  concepts::Connector& cntr, const concepts::Real3d& p, const Real t = 0.0) const{
   //key of current Element
     uint K = cntr.key();
     return K;
 }
 
virtual KeysInfo<F>* clone() const{return new KeysInfo<F>(*this);}
 
protected:
 virtual std::ostream& info(std::ostream& os) const{
   return os << concepts::typeOf(*this);
 }
}; //class
 
 
 
 
 
 
//,const Refinement<F>& ref
 
}//namespace estimator
 
#endif //refinementGraphics_hh