buildDofsBase.hh

Go to the documentation of this file.

 
#ifndef buildDofsBase2D_hh
#define buildDofsBase2D_hh
 
#include "hp2D/space.hh"
 
namespace hp2D {
 
  // forward declaration
   class Space;
 
  // ********************************************************* BuildDofsBase **
 
  class BuildDofsBase {
  public:
    BuildDofsBase() : spc_(0) {}
 
    virtual ~BuildDofsBase() {}
 
    BuildDofsBase(Space& spc) : spc_(&spc) {}
    virtual void operator()(concepts::Quad& cntr,
          concepts::TColumn<Real>*& T1,
          const uint nn[2]) = 0;
    virtual BuildDofsBase* clone(Space* spc = 0) const = 0;
    Space* space() { return spc_; }
  protected:
    inline concepts::AdaptiveControl<>& ctrl0_(uint idx);
    inline concepts::AdaptiveControlP<1>& ctrl1_(uint idx);
    inline concepts::AdaptiveControlP<2>& ctrl2_(uint idx);
    inline std::map<uint, concepts::VertexData>::const_iterator
    vertexListFind(uint idx) const;
    inline std::map<uint, concepts::VertexData>::const_iterator
    vertexListEnd() const;
    inline std::map<uint, concepts::EdgeData>::const_iterator
    edgeListFind(uint idx) const;
    inline std::map<uint, concepts::EdgeData>::const_iterator
    edgeListEnd() const;
    uint& dim_() { return spc_->dim_; }
    inline void deactivate_(const concepts::Vertex& vtx);
    inline void deactivate_(const concepts::Edge& edg);
    inline void computePmax_(const concepts::Quad& cntr, ushort Pmax[2]) const;
    Space* spc_;
  };
 
  concepts::AdaptiveControl<>& BuildDofsBase::ctrl0_(uint idx) {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->ctrl0_[idx];
  }
 
  concepts::AdaptiveControlP<1>& BuildDofsBase::ctrl1_(uint idx) {
    conceptsAssert(spc_, concepts::Assertion());
    return (*(spc_->ctrl1_))[idx];
  }
 
  concepts::AdaptiveControlP<2>& BuildDofsBase::ctrl2_(uint idx) {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->ctrl2_[idx];
  }
 
  std::map<uint, concepts::VertexData>::const_iterator
  BuildDofsBase::vertexListFind(uint idx) const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->vertexList_.find(idx);
  }
 
  std::map<uint, concepts::VertexData>::const_iterator
  BuildDofsBase::vertexListEnd() const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->vertexList_.end();
  }
 
  std::map<uint, concepts::EdgeData>::const_iterator
  BuildDofsBase::edgeListFind(uint idx) const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->edgeList_.find(idx);
  }
 
  std::map<uint, concepts::EdgeData>::const_iterator
  BuildDofsBase::edgeListEnd() const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->edgeList_.end();
  }
 
  void BuildDofsBase::deactivate_(const concepts::Vertex& vtx) {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->deactivate_(vtx);
  }
 
  void BuildDofsBase::deactivate_(const concepts::Edge& edg) {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->deactivate_(edg);
  }
 
  void BuildDofsBase::computePmax_(const concepts::Quad& cntr,
           ushort Pmax[2]) const {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->computePmax_(cntr, Pmax);
  }
 
} // namespace hp2D
 
#endif // buildDofsBase2D_hh