hp2D/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